;---------------------
;
; From version 10.10 3/3/83
;      version 11   19/2/06
;
;---------------------

FixBug          equ true                ;

XW              equ 28                  ;
YW              equ 21                  ;

pAttrib         equ #5800               ;
Characters      equ #6800               ;
ScorePos        equ #1201               ;
ManSpeed        equ 10                  ; Man move rate
FireLife        equ 50                  ; Fireball life
FBSR            equ 40                  ; Fireball search range
FireSpeed       equ 24                  ; Speed
LightLife       equ 100                 ; Lightning life
LtSR            equ 50                  ; Lightning search range
LightSpeed      equ 14                  ; Speed

nTreasure       equ 40                  ;
nMagic          equ 40                  ;

ArrowLife       equ 55                  ;
ArrowLifeMan    equ 32                  ;
ArrowSpeed      equ 15                  ;

FireDamageToMon  equ 40                 ; Hit points
LightDamageToMon equ 40                 ; Hit points
SwordDamageToMon equ 10                 ; Hit points

MaxTreasure     equ 5                   ;

nProj           equ 32                  ;
nMonst          equ 32                  ;

                org 0                   ; Displacements for projectiles
dp_Delay        ds 1                    ;
dp_iDelay       ds 1                    ;
dp_pMaze_L      ds 1                    ;
dp_pMaze_H      ds 1                    ;
dp_Off_L        ds 1                    ;
dp_Off_H        ds 1                    ;
dp_pCode_L      ds 1                    ;
dp_pCode_H      ds 1                    ;
dp_Life         ds 1                    ;
dp_MissileChar  ds 1                    ;
dp_BackingChar  ds 1                    ;
dp_Step1_L      ds 1                    ;
dp_Step1_H      ds 1                    ;
dp_ErrR         ds 1                    ;
dp_ErrS         ds 1                    ;
dp_ErrM         ds 1                    ;
dp_pOwner_L     ds 1                    ;
dp_pOwner_H     ds 1                    ;
dp_pTarget_L    ds 1                    ;
dp_pTarget_H    ds 1                    ;
dp_Origin_L     ds 1                    ;
dp_Origin_H     ds 1                    ;
dp_ManF         ds 1                    ;
dp_UpdateRate   ds 1                    ;
dp_TargetiPos_L ds 1                    ;
dp_TargetiPos_H ds 1                    ;
dp_pTarget2_L   ds 1                    ;
dp_pTarget2_H   ds 1                    ;
dp_RSave        ds 1                    ;
dp_pMazeSave_L  ds 1                    ;
dp_pMazeSave_H  ds 1                    ;

lProj           equ *                   ;

                ; These are only used during initial setup and overlay
                ; the code address store

dp_dX           equ dp_pCode_L          ;
dp_dY           equ dp_pCode_H          ;

                org 0                   ; Displacements for monsters

dm_pMaze_L      ds 1                    ;
dm_pMaze_H      ds 1                    ;
dm_Char         ds 1                    ;
dm_MoveType     ds 1                    ;
dm_Strength     ds 1                    ;
dm_Flags        ds 1                    ;
dm_Magic        ds 1                    ;
dm_MaxMagic     ds 1                    ;
dm_Treasure     ds 1                    ;
dm_MaxStrength  ds 1                    ;
dm_Delay        ds 1                    ;
dm_iDelay       ds 1                    ;
dm_nArrows      ds 1                    ;
dm_Wounds       ds 1                    ;
dm_Combat       ds 1                    ;
dm_Dirn         ds 1                    ;
dm_Cache        ds 4                    ;

lMonsterFixed   equ *                   ; Below this they're defined

dm_PastPos_L    ds 1                    ; These are zero'd on creation
dm_PastPos_H    ds 1                    ;
dm_TimeOut      ds 1                    ;
dm_AltMoveF     ds 1                    ;

lMonst          equ *                   ;

                org 0                   ; Ring save table
drt_pMaze_L     ds 1                    ;
drt_pMaze_H     ds 1                    ;
drt_Floor       ds 1                    ;

lRingTable      equ *                   ;

                org 0                   ; Maze monster definition
dml_pMaze_L     ds 1                    ;
dml_pMaze_H     ds 1                    ;
dml_Char        ds 1                    ;
dml_MoveType    ds 1                    ;

                org 0                   ; Maze monster definition
dst_Off_L       ds 1                    ;
dst_Off_H       ds 1                    ;
dst_Char        ds 1                    ;

Maze type definitions

dmo_Prob0       equ 0                   ;
dmo_Prob1       equ 8                   ;
dmo_Prob2       equ 16                  ;

                org #7000               ;

Seed            defs 4                  ;

                align 256               ;

MoveList        defw 0,0                ;
Conn            defb 0                  ;
pMan            defw BigMaze + 516      ;
nMan            defw BigMaze + 516      ;
pFrameX         defb 0                  ;
pFrameY         defb 0                  ;
MManDelay       defb 1                  ;
ManAngle        defb 1                  ;
ManOPosXY       defw #0404              ;
JustXDisp       defb -8                 ;

Init            ld hl,Maze              ;
                ld de,Maze+1            ;
                ld bc,#FF               ;
                ld (hl),0               ;
                ldir                    ;

                ld a,113                ;
                ld hl,BigMaze           ;
                ld de,BigMaze+1         ;

Initzzz         push hl                 ;
                push de                 ;

                ld bc,112               ;
                ld (hl),#20             ;
                ldir                    ;

                pop de                  ;
                pop hl                  ;

                ld bc,128               ;
                add hl,bc               ;

                ex de,hl                ;
                add hl,bc               ;
                ex de,hl                ;

                sub 1                   ;
                jr nz,Initzzz           ;

                ret                     ;

Draw            call FindMoves          ;
                ret c                   ;

                call Move               ;

                jp Draw                 ;

Main            call Init               ;

                call Rand               ;

                ld hl,Maze              ;
                ld l,a                  ;

Loop            call Draw               ;

                call Rnd7               ;
                jr nc Next              ;

                call FindLinks          ;

                call Link               ;

Next            call FindNext           ;
                ret c                   ;

                call FindLinks          ;
                jp c,Next               ;

                call Link               ;

                jp Loop                 ;

FindMoves       ld de,MoveList          ;
                ld bc,Maze              ;
                call TMU                ;
                call TMD                ;
                call TML                ;
                call TMR                ;
                ld a,e                  ;
                cp 1                    ;
                ret                     ;

TMU             ld a,l                  ;
                and #F0                 ;
                ret z                   ;

                ld a,l                  ;
                add a,#F0               ;
                ld c,a                  ;

                ld a,(bc)               ;
                or a                    ;
                ret nz                  ;

                ld a,1                  ;
                ld (de),a               ;
                inc de                  ;
                ret                     ;

TMD             ld a,l                  ;
                and #F0                 ;
                cp #F0                  ;
                ret z                   ;

                ld a,l                  ;
                add a,#10               ;
                ld c,a                  ;

                ld a,(bc)               ;
                or a                    ;
                ret nz                  ;

                ld a,2                  ;
                ld (de),a               ;
                inc de                  ;
                ret                     ;

TML             ld a,l                  ;
                and #0F                 ;
                ret z                   ;

                ld a,l                  ;
                dec a                   ;
                ld c,a                  ;

                ld a,(bc)               ;
                or a                    ;
                ret nz                  ;

                ld a,3                  ;
                ld (de),a               ;
                inc de                  ;
                ret                     ;

TMR             ld a,l                  ;
                and #0F                 ;
                cp #0F                  ;
                ret z                   ;

                ld a,l                  ;
                inc a                   ;
                ld c,a                  ;

                ld a,(bc)               ;
                or a                    ;
                ret nz                  ;

                ld a,4                  ;
                ld (de),a               ;
                inc de                  ;
                ret                     ;

Move            call Random             ;

                ld e,a                  ;
                ld a,3                  ;

                push hl                 ;
                push de                 ;
                call Rnd6               ;
                pop de                  ;
                pop hl                  ;

                ld a,b                  ;
                ld (Conn),a             ;

                ld a,(de)               ;
                dec a                   ;
                jp z,MoveUP             ;

                dec a                   ;
                jp z,MoveDOWN           ;

                dec a                   ;
                jp z,MoveLEFT           ;

MoveRIGHT       ld a,(Conn)             ;
                or (hl)                 ;
                ld (hl),a               ;

                ld a,l                  ;
                inc a                   ;
                ld l,a                  ;

                ld a,(Conn)             ;
                rlca                    ;
                rlca                    ;
                or (hl)                 ;
                ld (hl),a               ;
                ret                     ;

MoveLEFT        ld a,(Conn)             ;
                rlca                    ;
                rlca                    ;
                or (hl)                 ;
                ld (hl),a               ;

                ld a,l                  ;
                dec a                   ;
                ld l,a                  ;

                ld a,(Conn)             ;
                or (hl)                 ;
                ld (hl),a               ;
                ret                     ;

MoveDOWN        ld a,(Conn)             ;
                rrca                    ;
                rrca                    ;
                rrca                    ;
                rrca                    ;
                or (hl)                 ;
                ld (hl),a               ;

                ld a,l                  ;
                add a,#10               ;
                ld l,a                  ;

                ld a,(Conn)             ;
                rrca                    ;
                rrca                    ;
                or (hl)                 ;
                ld (hl),a               ;
                ret                     ;

MoveUP          ld a,(Conn)             ;
                rrca                    ;
                rrca                    ;
                or (hl)                 ;
                ld (hl),a               ;

                ld a,l                  ;
                add a,#F0               ;
                ld l,a                  ;

                ld a,(Conn)             ;
                rrca                    ;
                rrca                    ;
                rrca                    ;
                rrca                    ;
                or (hl)                 ;
                ld (hl),a               ;
                ret                     ;

FindNext        xor a                   ;
                ld b,a                  ;

Rst1            inc l                   ;
                cp (hl)                 ;
                ret z                   ;

                djnz Rst1               ;

                ret                     ;

FindLinks       ld de,MoveList          ;
                ld bc,Maze              ;

                call TryLinkUP          ;
                call TryLinkDOWN        ;
                call TryLinkLEFT        ;
                call TryLinkRIGHT       ;

                ld a,e                  ;
                cp 1                    ;
                ret                     ;

TryLinkUP       ld a,l                  ;
                and #F0                 ;
                ret z                   ;

                ld a,l                  ;
                add a,#F0               ;
                ld c,a                  ;

                ld a,(bc)               ;
                or a                    ;
                ret z                   ;

                and #30                 ;
                ret nz                  ;

                ld a,1                  ;
                ld (de),a               ;
                inc de                  ;
                ret                     ;

TryLinkDOWN     ld a,l                  ;
                and #F0                 ;
                cp #F0                  ;
                ret z                   ;

                ld a,l                  ;
                add a,#10               ;
                ld c,a                  ;

                ld a,(bc)               ;
                or a                    ;
                ret z                   ;

                and #C0                 ;
                ret nz                  ;

                ld a,2                  ;
                ld (de),a               ;
                inc de                  ;
                ret                     ;

TryLinkLEFT     ld a,l                  ;
                and #0F                 ;
                ret z                   ;

                ld a,l                  ;
                dec a                   ;
                ld c,a                  ;

                ld a,(bc)               ;
                or a                    ;
                ret z                   ;

                and #03                 ;
                ret nz                  ;

                ld a,3                  ;
                ld (de),a               ;
                inc de                  ;
                ret                     ;

TryLinkRIGHT    ld a,l                  ;
                and #0F                 ;
                cp #0F                  ;
                ret z                   ;

                ld a,l                  ;
                inc a                   ;
                ld c,a                  ;

                ld a,(bc)               ;
                or a                    ;
                ret z                   ;

                and #0C                 ;
                ret nz                  ;

                ld a,4                  ;
                ld (de),a               ;
                inc de                  ;
                ret                     ;

Link            push hl                 ;
                call Move               ;
                pop hl                  ;
                ret                     ;

Rand            call Rand1              ;

                ld a,(Seed)             ;
                ret                     ;

Rand1           ld hl,(Seed+2)          ;
                rl l                    ;
                rl h                    ;
                rl l                    ;
                rl h                    ;
                ld c,h                  ;
                ld a,(Seed)             ;
                rla                     ;
                ld b,a                  ;
                ld de,(Seed+1)          ;
                rl e                    ;
                rl d                    ;
                res 7,d                 ;
                ld hl,(Seed)            ;
                add hl,bc               ;
                ld (Seed),hl            ;
                ld hl,(Seed+2)          ;
                adc hl,de               ;
                res 7,h                 ;
                ld (Seed+2),hl          ;
                ret m                   ;
                ld hl,Seed              ;
Rnd1            inc (hl)                ;
                ret nz                  ;
                inc hl                  ;
                jp Rnd1                 ;

Rnd2            push hl                 ;
                push de                 ;
                push af                 ;

                call Rand               ;
                and 3                   ;
                ld b,a                  ;

                pop af                  ;
                pop de                  ;
                pop hl                  ;
                ret                     ;

Random          dec a                   ;
                ret z                   ;

                dec a                   ;
                jp z,Rnd3               ;

                dec a                   ;
                jp z,Rnd4               ;

                call Rnd2               ;

                ld a,b                  ;
                ret                     ;

Rnd3            call Rnd2               ;

                ld a,b                  ;
                and 1                   ;
                ret                     ;

Rnd4            ld a,2                  ;

Rnd5            call Rnd2               ;

                cp b                    ;
                jp c,Rnd5               ;

                ld a,b                  ;
                ret                     ;

Rnd6            ld b,1                  ;

                push bc                 ;
                call Rand               ;
                pop bc                  ;

                cp (iy+dmo_Prob1)       ;
                ret c                   ;

                inc b                   ;
                cp (iy+dmo_Prob2)       ;
                ret c                   ;

                inc b                   ;
                ret                     ;

Rnd7            push hl                 ;
                push de                 ;
                push bc                 ;

                call Rand               ;

                pop bc                  ;
                pop de                  ;
                pop hl                  ;

                cp (iy+dmo_Prob0)       ;
                ret                     ;

Page            ld hl,Maze              ;
                exx                     ;
                ld hl,BigMaze           ;

                ld c,#10                ;
Room1           ld b,#10                ;

Room            push bc                 ;
                call Corner             ;

                push hl                 ;
                call DrawDown           ;
                pop hl                  ;

                call DrawLeft           ;
                inc hl                  ;

                exx                     ;
                inc l                   ;
                exx                     ;

                pop bc                  ;
                djnz Room               ;

                ld de,#310              ;
                add hl,de               ;

                dec c                   ;
                jr nz,Room1             ;

PageC22         ld hl,BigMaze+#3800     ;
                ld ix,BigMaze+#3800-127 ;

                ld (hl),#99             ;
                inc hl                  ;

                ld b,#6F                ;

BottL1          ld a,(ix)               ;
                ld (hl),#93             ;

                cp #9C                  ;
                jr z Bottl2A            ;

                cp #94                  ;
                jr nz Bottl2            ;

Bottl2A         set 3,(hl)              ;

Bottl2          inc hl                  ;
                inc ix                  ;

                djnz BottL1             ;

                ld (hl),#9A             ;
                jp SideWall             ;

DrawWall        ld bc,WallDefs          ;
                rlca                    ;
                rlca                    ;
                rlca                    ;
                add a,c                 ;
                ld c,a                  ;
                ld a,b                  ;
                adc a,0                 ;
                ld b,a                  ;
                ld a,6                  ;
DrawLoop        ex af,af'               ;
                add hl,de               ;
                ld a,(bc)               ;
                ld (hl),a               ;
                inc bc                  ;
                ex af,af'               ;
                dec a                   ;
                jp nz,DrawLoop          ;
                ret                     ;

DrawDown        exx                     ;
                ld a,(hl)               ;
                exx                     ;
                and #C                  ;
                rrca                    ;
                rrca                    ;
                ld de,#80               ;
                call DrawWall           ;
                ret                     ;

DrawLeft        exx                     ;
                ld a,(hl)               ;
                exx                     ;
                and #C0                 ;
                rlca                    ;
                rlca                    ;
                or 4                    ;
                ld de,#1                ;
                call DrawWall           ;
                ret                     ;

Corner          exx                     ;
                ld e,9                  ;
                ld bc,Maze              ;
                call WallUP             ;
                rl e                    ;
                call WallDOWN           ;
                rl e                    ;
                call WallLEFT           ;
                rl e                    ;
                call WallRIGHT          ;
                rl e                    ;
                ld a,e                  ;
                exx                     ;
                cp #90                  ;
                jr nz CornerBlank       ;

                ld a,#20                ;
CornerBlank     ld (hl),a               ;
                ret                     ;

WallUP          ld a,l                  ;
                and #F0                 ;
                ret z                   ;

                ld a,l                  ;
                add a,#F0               ;
                ld c,a                  ;
                ld a,(bc)               ;
                and #C                  ;
                cp #C                   ;
                ret                     ;

WallDOWN        ld a,(hl)               ;
                and #C                  ;
                cp #C                   ;
                ret                     ;

WallLEFT        ld a,l                  ;
                and #F                  ;
                ret z                   ;

                ld a,l                  ;
                dec a                   ;
                ld c,a                  ;
                ld a,(bc)               ;
                and #C0                 ;
                cp #C0                  ;
                ret                     ;

WallRIGHT       ld a,(hl)               ;
                and #C0                 ;
                cp #C0                  ;
                ret                     ;

; Test the man-move keys. CF = move     ;

MMoveLR         ld bc,65278             ;
                in a,(c)                ;

                bit 1,a                 ;
                jr z MMLR1              ;

                bit 2,a                 ;
                jr z MMLR2              ;

MMLR0           or a                    ;
                ret                     ;

MMLR1           bit 2,a                 ;
                jr z MMLR0              ;

                ld a,3                  ;
                scf                     ;
                ret                     ;

MMLR2           bit 1,a                 ;
                jr z MMLR0              ;

                ld a,1                  ;
                scf                     ;
                ret                     ;

MMoveUD         ld bc,32766             ;
                in a,(c)                ;

                bit 3,a                 ;
                jr z MMUD1              ;

                bit 2,a                 ;
                jr z MMUD2              ;

                or a                    ;
                ret                     ;

MMUD1           bit 2,a                 ;
                jr z MMLR0              ;

                ld a,0                  ;
                scf                     ;
                ret                     ;

MMUD2           bit 3,a                 ;
                jr z MMLR0              ;

                ld a,2                  ;
                scf                     ;
                ret                     ;

MMoveDoor       ld hl,KeyOP             ;
                call ReadKey            ;
                jr nz MMDoorOpen        ;

                ld hl,KeyCP             ;
                call ReadKey            ;
                ret z                   ;

                ld hl,(pMan)            ;
                ld a,(ManAngle)         ;
                call CDirect            ;

                add hl,de               ;
                cp 2                    ;
                jr nz,MMDoorC1          ;

                add hl,de               ;

MMDoorC1        inc a                   ;
                and #3                  ;
                call CDirect            ;

                ld a,#20                ;
                cp (hl)                 ;
                ret nz                  ;

MMDoorC2        add hl,de               ;
                cp (hl)                 ;
                jr z,MMDoorC2           ;

                ld a,(hl)               ;
                and #F0                 ;
                cp #90                  ;
                ret nz                  ;

                ld b,4                  ;
                push hl                 ;
                ld hl,0                 ;
                or a                    ;
                sbc hl,de               ;
                ex de,hl                ;
                pop hl                  ;

                ld a,#20                ;
MMDoorC3        add hl,de               ;
                cp (hl)                 ;
                ret nz                  ;

                djnz MMDoorC3           ;

                add hl,de               ;

                ld a,(hl)               ;
                and #F0                 ;
                cp #90                  ;
                ret nz                  ;

                ld a,#DD                ;
                bit 0,e                 ;
                jr z,MMDoorC4           ;

                ld a,#DC                ;
MMDoorC4        push hl                 ;
                ld hl,0                 ;
                or a                    ;
                sbc hl,de               ;
                ex de,hl                ;
                pop hl                  ;

                ld b,4                  ;
MMDoorC5        add hl,de               ;
                ld (hl),a               ;
                push hl                 ;

                call SCV                ;

                call nc,OutIt           ;

                pop hl                  ;
                djnz MMDoorC5           ;

                ret                     ;

MMDoorOpen      ld a,(ManAngle)         ;
                call CDirect            ;

                ld hl,(pMan)            ;
                add hl,de               ;
                cp 2                    ;
                jr nz,MMDoorO1          ;

                add hl,de               ;

MMDoorO1        ld a,(hl)               ;
                and #FE                 ;
                cp #DC                  ;
                ret nz                  ;

                ld a,(ManAngle)         ;
                inc a                   ;
                and 3                   ;
                call CDirect            ;

MMDoorO2        add hl,de               ;
                ld a,(hl)               ;
                and #FE                 ;
                cp #DC                  ;
                jr z,MMDoorO2           ;

                ld a,#20                ;
                jr MMDoorC4             ;

MMKeepDrop      ld hl,KeyDP             ;
                call ReadKey            ;
                jp nz,MMDrop            ;

                ld hl,KeyKP             ;
                call ReadKey            ;
                ret z                   ;

                ld hl,(pMan)            ;
                ld a,(ManAngle)         ;
                call CDirect            ;
                cp 2                    ;
                jr nz,MMKeep1           ;

                add hl,de               ;
MMKeep1         add hl,de               ;

                call MMKeep2            ;
                ret nc                  ;

                ld a,(ManAngle)         ;
                rra                     ;
                ret nc                  ;

                ld de,128               ;
                add hl,de               ;

MMKeep2         ld c,(hl)               ;
                ld a,c                  ;
                and #F0                 ;
                cp #B0                  ;
                jr z,MMKTreasure        ;

                cp #C0                  ;
                jr z,MMKMagic           ;

                ld a,c                  ;
                and #FC                 ;
                cp #D8                  ;
                jr z,MMKArrow           ;

                and #F8                 ;
                cp #88                  ;
                jp z MMKRing            ;

                scf                     ;
                ret                     ;

MMKArrow        ld a,#20                ;
                ld (hl),a               ;

                call SCV                ;

                call nc,OutIt           ;

                ld a,(ArrowCount)       ;
                inc a                   ;
                ld (ArrowCount),a       ;

                or a                    ;
                ret                     ;

MMKTreasure     ld a,(TreasureCount)    ;
                cp MaxTreasure          ;
                ret z                   ;

                inc a                   ;
                ld (TreasureCount),a    ;

                ld e,a                  ;
                ld d,0                  ;
                ld ix,SwagBag-1         ;
                add ix,de               ;
                ld (ix),c               ;

                ld a,#20                ;
                ld (hl),a               ;

                call SCV                ;

                call nc,OutIt           ;

                or a                    ;
                ret                     ;

MMKMagic        ld a,MaxMagic           ;
                ld b,a                  ;
                ld a,c                  ;
                and #F                  ;
                add a,a                 ;
                ld c,a                  ;

                ld a,(CurrentMagic)     ;
                add a,c                 ;
                ret c                   ;

                cp b                    ;
                ret nc                  ;

                ld (CurrentMagic),a     ;

                ld a,#20                ;
                ld (hl),a               ;

                call SCV                ;

                call nc,OutIt           ;

                or a                    ;
                ret                     ;

MMDrop          ld a,(TreasureCount)    ;
                or a                    ;
                ret z                   ;

                ld c,a                  ;
                ld hl,(pMan)            ;
                ld a,(ManAngle)         ;
                call CDirect            ;
                cp 2                    ;
                jr nz,MMDrop1           ;

                add hl,de               ;

MMDrop1         add hl,de               ;
                ld a,(hl)               ;
                cp #20                  ;
                jr z,MMDrop2            ;

                ld a,(ManAngle)         ;
                rra                     ;
                ret nc                  ;

                ld de,128               ;
                add hl,de               ;
                ld a,(hl)               ;
                cp #20                  ;
                ret nz                  ;

MMDrop2         ld b,0                  ;
                ld ix,SwagBag-1         ;
                add ix,bc               ;

                ld a,(ix)               ;
                ld (hl),a               ;

                call SCV                ;

                call nc,OutIt           ;

                dec c                   ;
                ld a,c                  ;

                ld (TreasureCount),a    ;
                ret                     ;

; Drive the sword                       ;

MSword          ld a,(SwdPhase)         ; Are we swinging it?
                or a                    ;
                jr nz,MSDoing           ; Yes, calc next position

                ; No, is the "S" key pressed?

                ld hl,KeySP             ; "S" pressed?
                call ReadKey            ;
                jr z MSword_Auto        ; No, skip

                xor a                   ; Clear it
                ld (KeySP),a            ;

                ; Setup the swing       ;

MSA_Start       ld a,9+1                ; 9 phases
                ld (SwdPhase),a         ;

                jp MSDoing              ; Drive it

        ; Is there a monster in the sword range?

MSword_Auto     ld hl,(pMan)            ; Our head's position
                ld a,(ManAngle)         ; Which way are we facing?

                cp 3                    ;
                jr z MSA_Left           ;

                cp 1                    ;
                jr z MSA_Right          ;

                cp 0                    ;
                jr z MSA_Up             ;

                ; Assume down           ;

                inc h                   ; + 128 * 2
                dec hl                  ; Left

MSA_LR3         call MSA_IsMonster      ; Is this a monster?
                jr z MSA_Start          ; Yes

                inc hl                  ; Next char

                call MSA_IsMonster      ; Is this a monster?
                jr z MSA_Start          ; Yes

                inc hl                  ; Next char

                call MSA_IsMonster      ; Is this a monster?
                jr z MSA_Start          ; Yes

                ret                     ; Done

        ; Is this a monster?            ;

MSA_IsMonster   ld a,(hl)               ; Get the char
                and #F8                 ; Clip out irrelevent
                cp #D0                  ; Monster=ZF
                ret                     ;

        ; Try up                        ;

MSA_Up          ld de,-129              ; Up and left
                add hl,de               ;
                jp MSA_LR3              ; As above

        ; Try right                     ;

MSA_Right       inc hl                  ; Look right

MSA_UD2         call MSA_IsMonster      ; Is this a monster?
                jr z MSA_Start          ; Yes

                ld de,128               ; Down
                add hl,de               ;

                call MSA_IsMonster      ; Is this a monster?
                jr z MSA_Start          ; Yes

                ret                     ; Done

        ; Try left                      ;

MSA_Left        dec hl                  ; Look left
                jp MSA_UD2              ; As above

        ; Swing the sword. This changes according to the man's direction

MSDoing         ld hl,(SwdPos)          ; Undraw the sword
                ld a,(hl)               ;
                call SCV                ;
                call nc,OutIt           ;

                ; Time to give up on the sword?

                ld a,(SwdPhase)         ;
                dec a                   ;
                ld (SwdPhase),a         ;
                or a                    ;
                ret z                   ;

                ; Calc the new sword position

                ld a,(ManAngle)         ; Which way are we facing?
                call CDirect            ;

                ld hl,(pMan)            ; Add the offset
                add hl,de               ;

                cp 2                    ; If it's down we add it again
                jr nz,MSword1           ; to skip the feet...

                add hl,de               ; It is...

MSword1         ld (SwdPos),hl          ;

                ; Now, calc the offset and sword character

                ld iy,SwdUpTab          ;
                ld a,(ManAngle)         ;
                rlca                    ;
                rlca                    ;
                rlca                    ;
                rlca                    ;
                rlca                    ;
                ld d,0                  ;
                ld e,a                  ;
                add iy,de               ;
                ld a,(SwdPhase)         ;
                ld b,a                  ;
                ld a,9                  ;
                sub b                   ;
                ld b,a                  ;
                add a,a                 ;
                add a,b                 ;
                ld e,a                  ;
                add iy,de               ;

                ld d,(iy+dst_Off_H)     ;
                ld e,(iy+dst_Off_L)     ;
                ld hl,(SwdPos)          ;
                add hl,de               ;
                ld (SwdPos),hl          ;

                ld a,(hl)               ;

                cp #FD                  ; Stairs
                jr z,MSSkip             ; Yes, ignore

                and #FE                 ;
                cp #DC                  ;
                jr z,MSSkip             ;

                and #F8                 ;
                cp #D0                  ;
                jr z,MSHitMon           ;

                and #F0                 ;
                cp #90                  ;
                jr z,MSSkip             ;

                ld a,(iy+dst_Char)      ;
                call SCV                ;
                call nc,OutIt           ;

MSSkip          ret                     ;

MSStop          xor a                   ;
                ld (SwdPhase),a         ;
                ret                     ;

MSHitMon        ld a,SwordDamageToMon   ;
                ld b,#DE                ;
                call HitMonster         ;

                ret                     ;

; Move the man                          ;

MoveMan         ld a,(MManDelay)        ; Time to move?
                dec a                   ;
                ld (MManDelay),a        ;
                ret nz                  ; No, exit

                ld a,ManSpeed           ; Setup delay
                ld (MManDelay),a        ;

                call CQuit              ; Check for QUIT

                call MMoveDoor          ; Open/Close any doors?

                call MMKeepDrop         ; Keep/Drop anything?

                ; Don't allow attacks while in the doorway of the stairs

                ld hl,(pMan)            ; Check for force-field
                ld a,(hl)               ;
                cp #90                  ;
                jr z MMan5              ; Skip if in doorway

                call MFireArrow         ; Fire an arrow?

                call FireBall           ; Fire a fireball?

                call Lightning          ; Fire lightning?

                ; Move the man          ;

MMan5           xor a                   ; Clear the weapon key flags
                ld (KeyAP),a            ;
                ld (KeyFP)a             ;
                ld (KeyLP),a            ;

                ; Test man move keys  l/r -> 1/3 U/d -> 0/2

                call MMoveLR            ; Move left or right?
                jr c MoveMan10          ; l or r, so can't move up/down

                call MMoveUD            ; Move up or down?
                jp nc MManMoved         ; No, exit

                ; We have a movement request

MoveMan10       ld b,a                  ; Same angle?
                ld a,(ManAngle)         ;
                cp b                    ;
                jr z MoveMan11          ; Yes, skip

                ld a,b                  ; Store the new angle
                ld (ManAngle),a         ;

                ld a,30                 ; Angle changed, so extra delay
                ld (MManDelay),a        ;

                call PM                 ; Draw the new angle, same position

                ; We have the position, so drive the sword

MManMoved       jp MSword               ; Wave sword?

        ; Same direction, so we need to calculate a new position

MoveMan11       ld hl,(pMan)            ; Pointer to maze

                ld a,(UnderMan)         ; Anything under the man?
                or a                    ;
                jr nz MoveMAN12         ; Yes, skip

                ; Clear the man from the maze

                ld (hl),#20             ; Clear under the man
                ld de,128               ;
                add hl,de               ;
                ld (hl),#20             ;

                sbc hl,de               ; Move back

MoveMAN12       call SCV                ; Convert to screen coordinates
                ld (ManOPosXY),hl       ; Store screen coordinates

                ld ix,(pMan)            ;
                ld de,128               ;

                ld a,(ix)               ; Show the chars at the curr position
                call OutIt              ; This removes him from the screen
                inc h                   ;
                add ix,de               ;
                ld a,(ix)               ;
                call OutIt              ;

                ; Calc the new position ;

                ld a,(ManAngle)         ; Angle

                ld hl,(pMan)            ; Assume UP
                ld de,128               ;
                or a                    ;
                sbc hl,de               ;

                cp 0                    ; 0 -> UP
                jr z MManRE             ;

                add hl,de               ; Restore
                inc hl                  ; Assume RIGHT

                cp 1                    ; 1 -> RIGHT
                jr z MManRE             ;

                dec hl                  ; Restore
                add hl,de               ; Assume DOWN

                cp 2                    ; 2 -> DOWN
                jr z MManRE             ;

                or a                    ; Restore
                sbc hl,de               ;
                dec hl                  ; Must be LEFT

                ; See if we can move to here

MManRE          ld (nMan),hl            ; Store putative new position

                ld a,0                  ; We're not on a new floor
                ld (NFloorFl),a         ;

                ld a,(hl)               ; Is the head blocked?
                call ManValid           ;
                jp nz MMoveBlocked      ; Yes, draw it where it is

                ld de,128               ; Look down
                add hl,de               ;

                ld a,(hl)               ; Are the feet blocked?
                call ManValid           ;
                jp nz MMoveBlocked      ; Yes, draw it where it is

                ; We can move to here, but check if we're on a landing

                ld a,(hl)               ; Could we be on a landing?
                cp #80                  ;
                call nc MManRE1         ; Perhaps, check...

                xor #20                 ; Set this flag if there's something
                ld (UnderMan),a         ; other than a space under the man

                ld hl,(nMan)            ; Move to here...
                ld (pMan),hl            ;

                ; Calc the screen co-ordinates

                call SCV                ; Convert head to screen coordinates
                ld (ManOPosXY),hl       ; Save them
                jp c MManNewFrame       ; Skip if we've moved off-screen

                ld a,h                  ; Y
                cp YW+2                 ; At bottom
                jp z MManNewFrame       ;

                ; We're visible, show it here

                call PM                 ; Show the man

                ; See if we're on a landing

                ld a,(NFloorFl)         ; On a landing?
                or a                    ;
                call nz NFloor          ; Yes, see if the floor has changed

                jp MManMoved            ; Drive the sword

; Is this a character the man can move onto? z = Valid

ManValid        cp #20                  ; Space is OK
                ret z                   ;

                cp #90                  ; Force-field?
                jp z OpenPlan           ; Yes, see how we should treat it...

                and #FE                 ; ??
                cp #FC                  ;
                ret z                   ;

                and #F8                 ; Landing?
                cp #80                  ;
                ret                     ;

; On a landing?                         ;

MManRE1         cp #88                  ; Landing char?
                ret nc                  ; No, exit

                ; We're on a landing. Calc the floor...

                and #7                  ; Calc the floor, 1..8
                inc a                   ;
                ld (NFloorFl),a         ;

                ld a,(hl)               ; Restore the char
                ret                     ; Done

; Draw the man in the maze and on the screen

PM              ld a,(ManAngle)         ; Calc the right char for this angle
                add a,a                 ;
                add a,#A8               ;
                ld b,a                  ;

                ld hl,(pMan)            ; Get the man's position

                ld a,(hl)               ; Check the char under the head
                cp #80                  ;
                ld a,b                  ;
                jr nc PM1               ;

                ; Can overwrite this character

                ld (hl),a               ; Store the head in the maze
                ld de,128               ; Move down
                add hl,de               ;
                inc a                   ;
                ld (hl),a               ; Store feet
                dec a                   ;

                ; Show the man on the screen

PM1             ld hl,(ManOPosXY)       ; Position
                call OutIt              ; Write the man to the screen
                inc h                   ;
                inc a                   ;
                jp OutIt                ;

; Draw the man on the display only      ;

PMD             ld a,(ManAngle)         ;
                add a,a                 ;
                add a,#A8               ;
                jr PM1                  ;

MManNewFrame    ld a,(ManAngle)         ;
                ld hl,(pFrameX)         ;
                cp 0                    ;
                jr nz Scroll1           ;
                ld a,h                  ;
                sub YW                  ;
                ld h,a                  ;
                jr Scroll4              ;

Scroll1         cp 1                    ;
                jr nz Scroll2           ;
                ld a,l                  ;
                add a,XW                ;
                ld l,a                  ;
                jr Scroll4              ;

Scroll2         cp 2                    ;
                jr nz Scroll3           ;
                ld a,h                  ;
                add a,YW                ;
                ld h,a                  ;
                jr Scroll4              ;

Scroll3         ld a,l                  ;
                sub XW                  ;
                ld l,a                  ;

Scroll4         ld (pFrameX),hl         ;
                call NewScreen          ;
                ld hl,(pMan)            ;
                call SCV                ;
                call c,FuckUp           ;
                ld (ManOPosXY),hl       ;
                jp PM                   ;

MMoveBlocked    call PM                 ;

                jp MManMoved            ;

; Convert to screen co-ordinates        ;

SCV             push de                 ;
                push af                 ;

                call CFormat            ;
                ex de,hl                ;

                ld hl,(pFrameX)         ;
                ld a,e                  ;
                sub l                   ;
                ld l,a                  ;

                cp XW+4                 ;
                jr nc SCVF              ;

                ld a,d                  ;
                sub h                   ;
                ld h,a                  ;

                cp YW+3                 ;
                jr nc SCVF1             ;

                pop af                  ;
                pop de                  ;
                or a                    ;
                ret                     ;

SCVF            ld a,d                  ;
                sub h                   ;
                ld h,a                  ;

SCVF1           pop af                  ;
                pop de                  ;
                scf                     ;
                ret                     ;

CFormat         push de                 ;
                ld de,-BigMaze          ;
                add hl,de               ;
                pop de                  ;

                ld a,l                  ;
                and #7F                 ;
                add hl,hl               ;
                ld l,a                  ;

                ret                     ;

XYC             push af                 ;
                call CFormat            ;
                pop af                  ;
                ret                     ;

OutIt           push hl                 ;
                push de                 ;
                push af                 ;
                push bc                 ;
                push hl                 ;
                push hl                 ;

                ld h,Characters/256     ;
                ld l,a                  ;
                ld c,(hl)               ;
                pop hl                  ;
                ld de,SpecTab           ;
                push hl                 ;
                ld l,h                  ;
                ld h,0                  ;
                add hl,hl               ;
                add hl,de               ;
                ld e,(hl)               ;
                inc hl                  ;
                ld d,(hl)               ;
                pop hl                  ;
                ld h,0                  ;
                add hl,de               ;
                push hl                 ;
                ld l,a                  ;
                ld h,0                  ;
                add hl,hl               ;
                add hl,hl               ;
                add hl,hl               ;
                ld de,Characters        ;
                add hl,de               ;
                pop de                  ;

                ld b,8                  ;

OutItL          ld a,(hl)               ;
                ld (de),a               ;
                inc hl                  ;
                inc d                   ;
                djnz OutItL             ;

                pop hl                  ;
                ld a,l                  ;
                add a,a                 ;
                add a,a                 ;
                add a,a                 ;
                srl h                   ;
                rra                     ;
                srl h                   ;
                rra                     ;
                srl h                   ;
                rra                     ;
                ld l,a                  ;
                ld de,pAttrib           ;
                add hl,de               ;
                ld (hl),c               ;

OutItEx         pop bc                  ;
                pop af                  ;
                pop de                  ;
                pop hl                  ;
                ret                     ;

; Slightly faster version

OutIt_NR        push hl                 ;
                push hl                 ;

                ld h,Characters/256     ;
                ld l,a                  ;
                ld c,(hl)               ;
                pop hl                  ;
                ld de,SpecTab           ;
                push hl                 ;
                ld l,h                  ;
                ld h,0                  ;
                add hl,hl               ;
                add hl,de               ;
                ld e,(hl)               ;
                inc hl                  ;
                ld d,(hl)               ;
                pop hl                  ;
                ld h,0                  ;
                add hl,de               ;
                push hl                 ;
                ld l,a                  ;
                ld h,0                  ;
                add hl,hl               ;
                add hl,hl               ;
                add hl,hl               ;
                ld de,Characters        ;
                add hl,de               ;
                pop de                  ;

                ld b,8                  ;

OutItNRL        ld a,(hl)               ;
                ld (de),a               ;
                inc hl                  ;
                inc d                   ;
                djnz OutItNRL           ;

                pop hl                  ;
                ld a,l                  ;
                add a,a                 ;
                add a,a                 ;
                add a,a                 ;
                srl h                   ;
                rra                     ;
                srl h                   ;
                rra                     ;
                srl h                   ;
                rra                     ;
                ld l,a                  ;
                ld de,pAttrib           ;
                add hl,de               ;
                ld (hl),c               ;

                ret                     ; Done

InitTreasure    ld b,nTreasure          ;

InitTLoop       push bc                 ;

                call FindPosition       ;

                call Rnd7               ;
                and #F                  ;
                or #B0                  ;
                ld (hl),a               ;

                pop bc                  ;
                djnz InitTLoop          ;

                ret                     ;

InitMagic       ld b,nMagic             ;

InitMLoop       push bc                 ;

                call FindPosition       ;

                call Rnd7               ;
                and #F                  ;
                or #C0                  ;
                ld (hl),a               ;

                pop bc                  ;
                djnz InitMLoop          ;

                ret                     ;

FindPosition    call Rand               ;

                ld hl,(Seed)            ;
                ld a,l                  ;
                and #7F                 ;
                cp #70                  ;
                jr nc FindPosition      ;

                ld a,h                  ;
                and #3F                 ;
                ld h,a                  ;
                cp #38                  ;
                jr nc FindPosition      ;

                push de                 ;
                ld de,BigMaze           ;
                add hl,de               ;
                pop de                  ;

                ld a,(hl)               ;
                cp #20                  ;
                jr nz,FindPosition      ;

                ret                     ;

InitMonsters    ld b,nMonst             ;
                ld ix,MonsterList       ;

IMons0          push bc                 ;
                call IMons1             ;
                pop bc                  ;
                djnz IMons0             ;

                ld a,(cFloor)           ;
                or a                    ;
                ret z                   ;

                ld ix,MonsterList-lMonst
                ld de,lMonst            ;

IMons4          add ix,de               ;
                ld (ix+dm_Magic),#FF    ;
                ld (ix+dm_iDelay),30    ;

                dec a                   ;
                jr nz,IMons4            ;

                ld (ix+dm_Wounds),#FF   ;
                ret                     ;

                ret                     ;

IMons1          ld iy,MonsterTypes      ;
                ld b,lMonsterFixed      ;

IMons2          push bc                 ;

                ld a,(iy+lMonsterFixed) ; Get the variation
                call RandRange          ; Rand 0..Var-1
                add a,(iy)              ; +Base
                ld (ix),a               ; Store

                inc ix                  ;
                inc iy                  ;

                pop bc                  ;
                djnz IMons2             ;

                call FindPosition       ;

                ld (ix+dm_pMaze_L-lMonsterFixed),l
                ld (ix+dm_pMaze_H-lMonsterFixed),h

                ld a,(ix+dm_Char-lMonsterFixed)
                ld b,lMonst-lMonsterFixed

IMons3          ld (ix),0               ;
                inc ix                  ;
                djnz IMons3             ;

                ret                     ;

; Place the monsters in the maze        ;

PlaceMon        ld b,nMonst             ;
                ld ix,MonsterList       ;
                ld de,lMonst            ;

PlaceMonL       ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                ld a,(ix+dm_Char)       ;
                ld (hl),a               ;
                add ix,de               ;

                djnz PlaceMonL          ;

                ret                     ;

RandRange       or a                    ;
                ret z                   ;

                push hl                 ;
                push de                 ;
                push bc                 ;

                ld c,a                  ;
                call Rnd7               ;
                ld l,a                  ;
                xor a                   ;
                ld b,8                  ;
RandR1          rl l                    ;
                rla                     ;
                cp c                    ;
                jr c RandR2             ;

                sub c                   ;
RandR2          djnz RandR1             ;

                pop bc                  ;
                pop de                  ;
                pop hl                  ;
                ret                     ;

MoveMonsters    ld b,nMonst             ;
                ld ix,MonsterList       ;
                ld de,lMonst            ;

MMons1          dec (ix+dm_Delay)       ;
                call z MMons2           ;

                add ix,de               ;

                djnz MMons1             ;
                ret                     ;

MMons2          ld a,(ix+dm_iDelay)     ;
                ld (ix+dm_Delay),a      ;

                bit 7,(ix+dm_Flags)     ;
                jp nz SteamRise         ;

                bit 0,(ix+dm_Combat)    ;
                jr z MMons2A            ;

                ld a,(ix+dm_Char)       ;
                cp #D6                  ;
                jr nz MMons2Z           ;

                ld a,r                  ;
                and #7                  ;
                or #D0                  ;
                cp #D6                  ;
                jr nz MMons2B           ;

                inc a                   ;

MMons2B         ld (ix+dm_Char),a       ;
                jr nz MMons2Z           ;

MMons2A         ld a,(ix+dm_Char)       ;
                cp #D6                  ;
                jr z,MMons2Z            ;

                ld a,(Seed+1)           ;
                ld c,a                  ;
                ld a,r                  ;
                or c                    ;
                and #3F                 ;
                jr nz MMons2Z           ;

                push hl                 ;
                ld h,(ix+dm_pMaze_H)    ;
                ld l,(ix+dm_pMaze_L)    ;

                call SCV                ;
                jr nc MMons2X           ;

                ld (ix+dm_Char),#D6     ;
MMons2X         pop hl                  ;

MMons2Z         push ix                 ;
                push de                 ;
                push bc                 ;

                ld a,(ix+dm_Char)       ;
                cp #D6                  ;
                jr z,MMons5             ;

                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                ld (hl),#20             ;

                call SCV                ;
                jr c MMons3             ;

                ld a,#20                ;
                call OutIt              ;

MMons3          ld hl,MMons5            ;
                push hl                 ;

                ld a,(ix+dm_MoveType)   ;
                cp 2                    ;
                jp c MoveThing1         ;
                jp z MoveThing2         ;

                jp MoveThing3           ;

MMons5          call CheckCombat        ;

                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                ld a,(ix+dm_Char)       ;

                push af                 ;
                ld (hl),a               ;

                call SCV                ;
                jr c MMons4             ;

                pop af                  ;

                call OutIt              ;

                pop bc                  ;
                pop de                  ;
                pop ix                  ;
                ret                     ;

MMons4          pop af                  ;
                pop bc                  ;
                pop de                  ;
                pop ix                  ;
                ret                     ;

CheckCombat     call FindProjSpace      ;
                jp c CComNS             ;

                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                ld de,(pMan)            ;
                ld c,50                 ;
                call RangeLook          ;

                ld (iy+dp_Life),0       ;
                res 0,(ix+dm_Combat)    ;
                ret c                   ;

                ld a,1                  ;
                ld (Virgin),a           ;

                set 0,(ix+dm_Combat)    ;

                ld a,(iy+dp_ErrS)       ;
                or a                    ;
                jr nz CComNA            ;

                ld a,40                 ;
                call RandRange          ;

                cp d                    ;
                jr c CComNA             ;

                ld a,(ix+dm_nArrows)    ;
                or a                    ;
                jr z CComNA             ;

                dec (ix+dm_nArrows)     ;

                ld (iy+dp_Delay),ArrowSpeed
                ld (iy+dp_iDelay),ArrowSpeed

                ld a,(ix+dm_pMaze_L)    ;
                ld (iy+dp_pMaze_L),a    ;

                ld a,(ix+dm_pMaze_H)    ;
                ld (iy+dp_pMaze_H),a    ;

                ld l,(iy+dp_Step1_L)    ;
                ld (iy+dp_Off_L),l      ;
                ld h,(iy+dp_Step1_H)    ;
                ld (iy+dp_Off_H),h      ;

                ld a,l                  ;
                and #1                  ;
                xor #A1                 ;
                ld (iy+dp_MissileChar),a

                ld (iy+dp_Life),ArrowLife

                ld hl,MoveArrow         ;
                ld (iy+dp_pCode_L),l    ;
                ld (iy+dp_pCode_H),h    ;

                ld (iy+dp_BackingChar),0

                push ix                 ;

                push iy                 ;
                pop ix                  ;

                call MoveArrow          ;
                pop ix                  ;

CComNA          ld a,(ix+dm_Magic)      ;
                cp 6                    ;
                jp c,CComNS             ;

                ld c,a                  ;
                ld a,12                 ;

                call RandRange          ;

                cp c                    ;
                jp nc,CComNS            ;

                ld a,r                  ;
                and #7                  ;
                cp 2                    ;
                ret nc                  ;

                or a                    ;
                jr nz,CComFire          ;

                ld hl,(pMan)            ;
                ld e,(ix+dm_pMaze_L)    ;
                ld d,(ix+dm_pMaze_H)    ;
                call InitLine           ;

                ld (iy+dp_MissileChar),#A0
                ld (iy+dp_Delay),LightSpeed
                ld (iy+dp_iDelay),LightSpeed

                ld hl,MoveLight         ;
                ld (iy+dp_pCode_L),l    ;
                ld (iy+dp_pCode_H),h    ;

                ld (iy+dp_Life),LightLife

                ld (iy+dp_BackingChar),0

                ld a,(ix+dm_Magic)      ;
                sub 6                   ;
                ld (ix+dm_Magic),a      ;

                jp CComNS               ;

CComFire        ld a,(ix+dm_Magic)      ;
                cp 10                   ;
                jp c,CComNS             ;

                call FindProjSpace      ;

                ld hl,(pMan)            ;
                ld e,(ix+dm_pMaze_L)    ;
                ld d,(ix+dm_pMaze_H)    ;
                call InitLine           ;

                ld (iy+dp_Delay),FireSpeed
                ld (iy+dp_iDelay),FireSpeed
                ld hl,MoveFire          ;
                ld (iy+dp_pCode_L),l    ;
                ld (iy+dp_pCode_H),h    ;

                ld (iy+dp_Life),FireLife

                ld (iy+dp_BackingChar),0
                ld (iy+dp_MissileChar),#A4

                push ix                 ;
                pop hl                  ;
                ld (iy+dp_pOwner_L),l   ;
                ld (iy+dp_pOwner_H),h   ;

                ld hl,pMan              ;
                ld (iy+dp_pTarget_L),l  ;
                ld (iy+dp_pTarget_H),h  ;

                ld (iy+dp_ManF),0       ;
                ld (iy+dp_UpdateRate),1 ;

                ld hl,(pMan)            ;
                ld (iy+dp_TargetiPos_L),l
                ld (iy+dp_TargetiPos_H),h

                ld (iy+dp_pTarget2_L),0 ;
                ld (iy+dp_pTarget2_H),0 ;

                ld a,(ix+dm_Magic)      ;
                sub 10                  ;
                ld (ix+dm_Magic),a      ;

CComNS          ret                     ;

; Justify our position on screen?       ;

JustifyScreen   ld hl,KeyspP            ;
                call ReadKey            ;
                ret z                   ;

; Yes, justify it...                    ;

JustifyT        ld a,(ManAngle)         ; Which way are we facing?
                ld h,-8                 ; Assume right-facing justify

                cp 1                    ; Right?
                jr z JustGotXDisp       ; Yep, skip

                ld h,-16                ; Assume left-facing justify

                cp 3                    ; Left?
                jr z JustGotXDisp       ;

                ld a,(JustXDisp)        ; Get the last offset
                ld h,a                  ;

JustGotXDisp    ld a,h                  ; Store it
                ld (JustXDisp),a        ;

                ; Now justify us...     ;

                ld hl,(pMan)            ;
                call XYC                ;

                ld d,h                  ;
                ld h,l                  ;
                dec h                   ;
                call Bound7             ;

                ; Sub either 8 or 16    ;

                ld l,a                  ;
                ld a,(JustXDisp)        ;
                add a,l                 ;
                ld l,a                  ;

                ld h,d                  ;
                call Bound7             ;
                sub 8                   ;
                ld h,a                  ;
                ex de,hl                ;
                ld hl,(pFrameX)         ;

                ld a,(JFLAG)            ;
                or a                    ;
                jr nz,JUST              ;

                sbc hl,de               ;
                ret z                   ;

JUST            xor a                   ;
                ld (JFLAG),a            ;

                ld hl,(ManOPosXY)       ;

                ld a,#20                ;
                call OutIt              ;
                inc h                   ;
                call OutIt              ;

                ld (pFrameX),de         ;
                ld hl,(pMan)            ;
                call SCV                ;

                ld (ManOPosXY),hl       ;

                call NewScreen          ;

                call PM                 ;

                ret                     ;

BackwardCon     res 7,l                 ;
                rl l                    ;
                srl h                   ;
                rr l                    ;

                push de                 ;
                ld de,BigMaze           ;
                add hl,de               ;
                pop de                  ;

                ret                     ;

NewScreen       ld iy,(pFrameX)         ;
                ld hl,#0000             ;
                ld b,YW+3               ;

NewS1           push bc                 ;
                ld b,XW+4               ;

NewS2           push bc                 ;
                push hl                 ;
                call NewSGet            ;
                pop hl                  ;

                push hl                 ; Save
                call OutIt_NR           ;
                pop hl                  ;
                inc iyl                 ;

                inc l                   ;
                pop bc                  ;
                djnz NewS2              ;

                ld a,(pFrameX)          ;
                ld iyl,a                ;

                inc iyh                 ;

                ld l,0                  ;
                inc h                   ;

                pop bc                  ;
                djnz NewS1              ;

                ret                     ;

NewSGet         push iy                 ;
                pop bc                  ;

                ld a,b                  ;
                cp #71                  ;
                jp nc NewSGet2          ;

                ld a,c                  ;
                cp #80                  ;
                jp nc NewSGet2          ;

                push iy                 ;
                pop hl                  ;

                call BackwardCon        ;

                ld a,iyl                ;
                ; cp #70                ;
                ld a,(hl)               ;
                ret                     ;

NewSGet2        ld a,#FF                ;
                ret                     ;

MTNewDir        call MonKeep            ;
                ret nc                  ;

                ld a,r                  ;
                and #7                  ;
                ld (ix+dm_Dirn),a       ;

                ld a,(hl)               ;
                and #F0                 ;
                cp #90                  ;
                ret nz                  ;

                ld a,(ix+dm_AltMoveF)   ;
                or a                    ;
                ret z                   ;

                call RandWallFoll       ;

                ld (ix+dm_MoveType),a   ;
                ld (ix+dm_AltMoveF),0   ;

MoveT2Mark      ld a,(ix+dm_pMaze_L)    ;
                ld (ix+dm_PastPos_L),a  ;

                ld a,(ix+dm_pMaze_H)    ;
                ld (ix+dm_PastPos_H),a  ;

                ld (ix+dm_TimeOut),1    ;
                ret                     ;

RandWallFoll    ld a,r                  ;
                and #1                  ;
                or #2                   ;
                ret                     ;

SteamRise       ld a,(ix+dm_Char)       ;
                cp #E0                  ;
                ret c                   ;

                inc a                   ;
                and #E3                 ;
                ld (ix+dm_Char),a       ;

                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                ld (hl),a               ;

                call SCV                ;

                call nc OutIt           ;
                ret                     ;

CDirect1        ld de,-129              ;
                cp 4                    ;
                ret z                   ;

                ld de,-127              ;
                cp 5                    ;
                ret z                   ;

                ld de,129               ;
                cp 6                    ;
                ret z                   ;

                ld de,127               ;
                cp 7                    ;
                ret z                   ;

CDirect         ld de,-128              ;
                cp 0                    ;
                ret z                   ;

                ld de,1                 ;
                cp 1                    ;
                ret z                   ;

                ld de,128               ;
                cp 2                    ;
                ret z                   ;

                ld de,-1                ;
                cp 3                    ;
                ret z                   ;

                ld de,0                 ;
                ret                     ;

MoveThing1      ld a,(ix+dm_Dirn)       ;
                call CDirect1           ;

                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                add hl,de               ;
                call MonODoor           ;

                ld a,(hl)               ;
                cp #20                  ;
                jp nz MTNewDir          ;

                ld (ix+dm_pMaze_L),l    ;
                ld (ix+dm_pMaze_H),h    ;

                ld a,r                  ;
                and #70                 ;
                jp z MTNewDir           ;

                ret                     ;

MoveThing2      ld a,(ix+dm_TimeOut)    ;
                or a                    ;
                call z MoveT2Mark       ;

                inc (ix+dm_TimeOut)     ;

                ld a,(ix+dm_Dirn)       ;
                call CDirect            ;

                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                add hl,de               ;
                call MonODoor           ;

                ld a,(hl)               ;
                cp #20                  ;
                jr z MTNewDir2          ;

                call MonKeep            ;
                ret nc                  ;

                ld a,(ix+dm_Dirn)       ;
                dec a                   ;
                and #3                  ;
                ld (ix+dm_Dirn),a       ;

WallFC          ld e,(ix+dm_PastPos_L)  ;
                ld d,(ix+dm_PastPos_H)  ;
                or a                    ;
                sbc hl,de               ;

                push af                 ;
                add hl,de               ;
                pop af                  ;
                ret nz                  ;

                call MoveT2Mark         ;

                ld (ix+dm_MoveType),1   ;
                ld (ix+dm_AltMoveF),1   ;

                ld a,r                  ;
                and #3                  ;
                or #4                   ;
                ld (ix+dm_Dirn),a       ;

                ret                     ;

MTNewDir2       ld a,(ix+dm_Dirn)       ;
                inc a                   ;
                and #3                  ;
                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                call CDirect            ;

                add hl,de               ;
                call MonODoor           ;

                ld a,(hl)               ;
                cp #20                  ;
                jr nz MTNewDir2A        ;

                ld (ix+dm_pMaze_L),l    ;
                ld (ix+dm_pMaze_H),h    ;

                ld a,(ix+dm_Dirn)       ;
                inc a                   ;
                and #3                  ;
                ld (ix+dm_Dirn),a       ;

                jp WallFC               ;

MTNewDir2A      ld a,(ix+dm_Dirn)       ;
                call CDirect            ;

                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                add hl,de               ;
                ld (ix+dm_pMaze_L),l    ;
                ld (ix+dm_pMaze_H),h    ;

                jp WallFC               ;

MoveThing3      ld a,(ix+dm_TimeOut)    ;
                or a                    ;
                call z MoveT2Mark       ;

                inc (ix+dm_TimeOut)     ;

                ld a,(ix+dm_Dirn)       ;
                and #3                  ;
                call CDirect            ;

                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                add hl,de               ;
                call MonODoor           ;

                ld a,(hl)               ;
                cp #20                  ;
                jr z MTNewDir3          ;

                call MonKeep            ;
                ret nc                  ;

                ld a,(ix+dm_Dirn)       ;
                inc a                   ;
                and #3                  ;
                ld (ix+dm_Dirn),a       ;

                jp WallFC               ;

MTNewDir3       ld a,(ix+dm_Dirn)       ;
                dec a                   ;
                and #3                  ;
                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                call CDirect            ;

                add hl,de               ;
                call MonODoor           ;

                ld a,(hl)               ;
                cp #20                  ;
                jr nz MTNewDir3A        ;

                ld (ix+dm_pMaze_L),l    ;
                ld (ix+dm_pMaze_H),h    ;

                ld a,(ix+dm_Dirn)       ;
                dec a                   ;
                and #3                  ;
                ld (ix+dm_Dirn),a       ;

                jp WallFC               ;

MTNewDir3A      ld a,(ix+dm_Dirn)       ;
                call CDirect            ;

                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                add hl,de               ;
                ld (ix+dm_pMaze_L),l    ;
                ld (ix+dm_pMaze_H),h    ;

                jp WallFC               ;

MonKeep         ld c,a                  ;
                and #F0                 ;
                cp #C0                  ;
                jr z MonMagic           ;

                cp #B0                  ;
                jr z MonTreas           ;

                scf                     ;
                ret                     ;

MonMagic        ld a,c                  ;
                and #F                  ;
                ld c,a                  ;

                ld a,(ix+dm_Magic)      ;
                add a,c                 ;
                add a,c                 ;
                ret c                   ;

                cp (ix+dm_MaxMagic)     ;
                ccf                     ;
                ret c                   ;

                ld (ix+dm_Magic),a      ;

KillIt          ld a,#20                ;
                ld (hl),a               ;

                call SCV                ;

                call nc,OutIt           ;

                or a                    ;
                ret                     ;

MonTreas        ld a,(ix+dm_Treasure)   ;
                cp 4                    ;
                ccf                     ;
                ret c                   ;

                inc (ix+dm_Treasure)    ;
                ld e,a                  ;
                ld d,0                  ;

                push ix                 ;
                add ix,de               ;
                ld (ix+dm_Cache),c      ;
                pop ix                  ;

                jp KillIt               ;

Delay           ret                     ;

MoveProj        ld b,nProj              ;
                ld ix,ProjList          ;

MProj1          push bc                 ;

                ld a,(ix+dp_Life)       ;
                or a                    ;
                call nz MProj2          ;

                ld de,lProj             ;
                add ix,de               ;

                pop bc                  ;
                djnz MProj1             ;

                ret                     ;

MProj2          dec (ix+dp_Delay)       ;
                ret nz                  ;

MProj2A         ld a,(ix+dp_iDelay)     ;
                ld (ix+dp_Delay),a      ;

                ld l,(ix+dp_pMaze_L)    ;
                ld h,(ix+dp_pMaze_H)    ;
                ld a,(ix+dp_Life)       ;

                dec (ix+dp_Life)        ;
                jr nz MProj3            ;

                ld a,(ix+dp_BackingChar)
                or a                    ;
                ret z                   ;

                ld a,#20                ;
                ld (hl),a               ;

                call SCV                ;

                call nc OutIt           ;

                ret                     ;

MProj3          ld de,MProj4            ;
                push de                 ;

                ld a,(ix+dp_BackingChar)
                or a                    ;
                jr z MProj3A            ;

                ld a,#20                ;
                ld (hl),a               ;

                call SCV                ;

                call nc OutIt           ;

MProj3A         ld l,(ix+dp_pCode_L)    ;
                ld h,(ix+dp_pCode_H)    ;
                jp (hl)                 ;

MProj4          ld a,(ix+dp_Life)       ;
                or a                    ;
                ret z                   ;

                ld l,(ix+dp_pMaze_L)    ;
                ld h,(ix+dp_pMaze_H)    ;

                ld a,(hl)               ;
                cp #20                  ;
                jr nz MProj4A           ;

                ld a,(ix+dp_MissileChar)
                ld (hl),a               ;

                ld (ix+dp_BackingChar),1

                call SCV                ;

                call nc OutIt           ;

                ret                     ;

MProj4A         ld (ix+dp_BackingChar),0
                ret                     ;

IPL             ld bc,nProj*lProj-1     ;
                ld hl,ProjList          ;
                ld de,ProjList+1        ;
                ld (hl),0               ;
                ldir                    ;

                ret                     ;

MFireArrow      ld hl,KeyAP             ;
                call ReadKey            ;
                ret z                   ;

                call FindProjSpace      ;

                push iy                 ;
                pop ix                  ;
                ret c                   ;

                ld a,(ArrowCount)       ;
                or a                    ;
                ret z                   ;

                dec a                   ;
                ld (ArrowCount),a       ;

                ld hl,(pMan)            ;
                ld a,(ArrDir)           ;

                call CDirect            ;
                cp 2                    ;
                jr nz MFAr1             ;

                add hl,de               ;
                jp MFA0                 ;

MFAr1           or a                    ;
                jp z,MFA0               ;

                push af                 ;
                push hl                 ;
                pop iy                  ;
                xor a                   ;
                ex af,af'               ;
                xor a                   ;
                ld (MFAr3B+2),a         ;
                ld a,#80                ;
                ld (MFArOff1+2),a       ;

                ld bc,128               ;
                add iy,bc               ;

                ld b,(ix+dp_Life)       ;
MFAr3           add iy,de               ;

MFArOff1        ld a,(iy-128)           ;
                and #FE                 ;
                cp #DC                  ;
                jr z,MFAr5              ;

                and #F8                 ;
                cp #D0                  ;
                jr z,MFAr5              ;

                and #F0                 ;
                cp #90                  ;
                jr nz,MFAr3B            ;

                ex af,af'               ;
                jr nz,MFAr5             ;

                or #FF                  ;
                ex af,af'               ;
                ld a,#0                 ;
                ld (MFArOff1+2),a       ;

MFAr3B          ld a,(iy)               ;
                and #FE                 ;
                cp #DC                  ;
                jr z,MFAr5              ;

                and #F8                 ;
                cp #D0                  ;
                jr z,MFAr7              ;

                and #F0                 ;
                cp #90                  ;
                jr nz,MFAr3A            ;

                ex af,af'               ;
                jr nz,MFAr5             ;

                or #FF                  ;
                ex af,af'               ;

                ld a,#80                ;
                ld (MFAr3B+2),a         ;

MFAr3A          djnz MFAr3              ;

                jr MFAr5                ;

MFAr7           ld bc,128               ;
                add hl,bc               ;

MFAr5           pop af                  ;

MFA0            ld (ix+dp_Off_L),e      ;
                ld (ix+dp_Off_H),d      ;
                ld (ix+dp_pMaze_L),l    ;
                ld (ix+dp_pMaze_H),h    ;
                ld (ix+dp_BackingChar),0;
                ld (ix+dp_Life),ArrowLifeMan;
                bit 0,a                 ;
                ld a,#A0                ;
                jr nz MFA1              ;

                inc a                   ;

MFA1            ld (ix+dp_MissileChar),a

                ld hl,MoveArrow         ;
                ld (ix+dp_pCode_L),l    ;
                ld (ix+dp_pCode_H),h    ;

                ld hl,#0505             ;
                ld (ix+dp_Delay),l      ;
                ld (ix+dp_iDelay),h     ;

                jp MProj2A              ;

MArr1           ld (ix+dp_Life),0       ;
                ret                     ;

MoveArrow       ld l,(ix+dp_pMaze_L)    ;
                ld h,(ix+dp_pMaze_H)    ;
                ld e,(ix+dp_Off_L)      ;
                ld d,(ix+dp_Off_H)      ;
                add hl,de               ;
                ld (ix+dp_pMaze_L),l    ;
                ld (ix+dp_pMaze_H),h    ;

                ld a,(hl)               ;
                cp #20                  ;
                ret z                   ;

                and #FE                 ;
                cp #DC                  ;
                jr z MArr1              ;

                and #F0                 ;
                cp #90                  ;
                jr z MArr1              ;

                ld a,(hl)               ;
                and #F8                 ;
                cp #D0                  ;
                jp z HMon               ;

                cp #A8                  ;
                ret nz                  ;

                ld a,(ix+dp_Life)       ;
                ld (ix+dp_Life),0       ;
                add a,25                ;

                sra a                   ;

HitMan          ld b,a                  ;

                ld a,(Wounds)           ;
                add a,b                 ;
                ld (Wounds),a           ;

                cp MaxWounds            ;
                jp nc ManKilled         ;

                ret                     ;

HitManFire      call MFire1             ;

                ld a,15                 ;
                jr HitMan               ;

HitManLight     ld a,10                 ;
                jr HitMan               ;

HMon            ld a,70                 ;
                ld b,#DF                ;
                ld (ix+dp_Life),0       ;

HitMonster      ld c,a                  ;
                ld a,b                  ;
                ld (TempStore),a        ;

                ld iy,MonsterList       ;
                ex de,hl                ;

                ld b,nMonst             ;

HMon1           ld l,(iy+dm_pMaze_L)    ;
                ld h,(iy+dm_pMaze_H)    ;
                or a                    ;
                sbc hl,de               ;
                jr z HMon2              ;

                exx                     ;
                ld de,lMonst            ;
                add iy,de               ;
                exx                     ;

                djnz HMon1              ;

                call FuckUp             ;

HMon2           ld a,(iy+dm_Wounds)     ;
                sub c                   ;
                ld (iy+dm_Wounds),a     ;

                jr c HMonKill           ;

                ret                     ;

HMonKill        ld (iy+dm_Flags),#FF    ;
                ld l,(iy+dm_pMaze_L)    ;
                ld h,(iy+dm_pMaze_H)    ;

                ld a,(TempStore)        ;
                ld (hl),a               ;
                ld (iy+dm_Char),a       ;

                call SCV                ;

                call nc OutIt           ;

                ld a,(nDTs)             ;
                inc a                   ;
                ld (nDTs),a             ;
                ret nz                  ;

                dec a                   ;
                ld (nDTs),a             ;

                ret                     ;

InitLine        ld (iy+dp_pMaze_L),e    ;
                ld (iy+dp_pMaze_H),d    ;
                ld (iy+dp_dX),1         ;
                ld (iy+dp_dY),1         ;

                call XYC                ;

                ex de,hl                ;
                call XYC                ;
                ex de,hl                ;

                ld a,l                  ;
                sub e                   ;
                ld l,a                  ;
                jp z ILine1A            ;
                jp p ILine1             ;

                neg                     ;
                ld (iy+dp_dX),#FF       ;

ILine1          ld e,a                  ;
                ld a,h                  ;
                sub d                   ;
                ld h,a                  ;
                jp z ILine2A            ;
                jp p ILine2             ;

                neg                     ;
                ld (iy+dp_dY),#FF       ;

ILine2          ld d,a                  ;
                sub e                   ;
                jr nc ILine3            ;

                ld (iy+dp_Life),e       ;
                ld (iy+dp_ErrM),e       ;
                sra e                   ;
                ld (iy+dp_ErrR),e       ;
                ld (iy+dp_ErrS),d       ;

                call ILine4             ;

                ld (iy+dp_Off_L),l      ;
                ld (iy+dp_Off_H),h      ;
                ld (iy+dp_dY),0         ;

                call ILine4             ;

                ld (iy+dp_Step1_L),l    ;
                ld (iy+dp_Step1_H),h    ;
                ret                     ;

ILine3          ld (iy+dp_Life),d       ;
                ld (iy+dp_ErrM),d       ;
                sra d                   ;
                ld (iy+dp_ErrR),d       ;
                ld (iy+dp_ErrS),e       ;

                call ILine4             ;

                ld (iy+dp_Off_L),l      ;
                ld (iy+dp_Off_H),h      ;
                ld (iy+dp_dX),0         ;

                call ILine4             ;

                ld (iy+dp_Step1_L),l    ;
                ld (iy+dp_Step1_H),h    ;
                ret                     ;

ILine1A         ld (iy+dp_dX),0         ;
                jr ILine1               ;

ILine2A         ld (iy+dp_dY),0         ;
                jr ILine2               ;

ILine4          ld a,(iy+dp_dX)         ;
                cp #FF                  ;
                jr z ILine4A            ;

                ld a,(iy+dp_dY)         ;
                cp #FF                  ;
                jr z ILine4B            ;

                ld h,a                  ;
                srl h                   ;
                ld l,0                  ;
                rr l                    ;
                ld a,(iy+dp_dX)         ;
                or l                    ;
                ld l,a                  ;

                ret                     ;

ILine4A         ld a,(iy+dp_dY)         ;
                cp #FF                  ;
                jr z ILine4AA           ;

                or a                    ;
                jr z ILine4AB           ;

                ld hl,127               ;
                ret                     ;

ILine4AA        ld hl,-129              ;
                ret                     ;

ILine4AB        ld hl,-1                ;
                ret                     ;

ILine4B         ld a,(iy+dp_dX)         ;
                ld hl,-128              ;
                or l                    ;
                ld l,a                  ;
                ret                     ;

NextPoint       dec (iy+dp_Life)        ;

                ld a,(iy+dp_Life)       ;
                inc a                   ;
                jr nz NextPointA        ;

                ld (iy+dp_Life),a       ;
                scf                     ;
                ret                     ;

NextPointA      ld l,(iy+dp_pMaze_L)    ;
                ld h,(iy+dp_pMaze_H)    ;

                ld a,(iy+dp_ErrR)       ;
                sub (iy+dp_ErrS)        ;
                ld (iy+dp_ErrR),a       ;
                jp p NextPoint1         ;

                ld e,(iy+dp_Off_L)      ;
                ld d,(iy+dp_Off_H)      ;
                add hl,de               ;
                ld (iy+dp_pMaze_L),l    ;
                ld (iy+dp_pMaze_H),h    ;

                ld a,(iy+dp_ErrR)       ;
                add a,(iy+dp_ErrM)      ;
                ld (iy+dp_ErrR),a       ;

                or a                    ;
                ret                     ;

NextPoint1      ld e,(iy+dp_Step1_L)    ;
                ld d,(iy+dp_Step1_H)    ;
                add hl,de               ;
                ld (iy+dp_pMaze_L),l    ;
                ld (iy+dp_pMaze_H),h    ;

                or a                    ;
                ret                     ;

MonsterSearch   ld ix,MonsterList       ;
                ld (pNearMonster),hl    ;

                ld hl,MonSRange         ;
                ld (hl),#FF             ;

                ld hl,(pNearMonster)    ;
                ld b,nMonst             ;

MonSearchLoop   bit 7,(ix+dm_Flags)     ;
                jr nz,MonSNext          ;

                bit 7,(ix+dm_Combat)    ;
                jr nz MonSNext          ;

                ld e,(ix+dm_pMaze_L)    ;
                ld d,(ix+dm_pMaze_H)    ;
                call RangeLook          ;
                jr c,MonSNext           ;

                ex af,af'               ;
                ld a,(MonSRange)        ;
                cp d                    ;
                jr c,MonSNext1          ;

                ld a,d                  ;
                ld (MonSRange),a        ;

                ld (pNearMonster),ix    ;

MonSNext1       ex af,af'               ;

MonSNext        ld de,lMonst            ;
                add ix,de               ;

                djnz MonSearchLoop      ;

                ld a,(MonSRange)        ;
                add a,1                 ;

                ret                     ;

RangeDoor       push bc                 ;
                push de                 ;
                push hl                 ;

                call XYC                ;
                ex de,hl                ;
                call XYC                ;
                ld b,a                  ;
                ld a,e                  ;
                sub l                   ;
                jp p,RL1                ;

                neg                     ;
RL1             cp c                    ;
                jp p,RLFail             ;

                ld a,d                  ;
                sub h                   ;
                jp p,RL2                ;

                neg                     ;
RL2             cp c                    ;
                jp p,RLFail             ;

                pop de                  ;
                pop hl                  ;
                push hl                 ;
                push de                 ;

                xor a                   ;
                ld (DoorFlag),a         ;

                call InitLine           ;

                call NextPoint          ;
                jr c,RLPassed           ;

                ld a,(hl)               ;
                and #FE                 ;
                cp #DC                  ;
                jr z,RLFDoor            ;

                and #F0                 ;
                cp #90                  ;
                jr z,RLFail             ;

                jr RL4                  ;

RLFDoor         ld (DoorFlag),a         ;

RL4             call NextPoint          ;
                jr c,RLPassed           ;

                ld a,(hl)               ;
                and #FE                 ;
                cp #DC                  ;
                jr z,RLFail             ;

                or #F                   ;
                cp #9F                  ;
                jr z,RLFail             ;

                jr RL4                  ;

RLFail          ld a,b                  ;
                scf                     ;
                jr RLEnd                ;

RLPassed        ld a,b                  ;
                or a                    ;

RLEnd           pop hl                  ;
                pop de                  ;
                ld d,(iy+dp_ErrM)       ;
                pop bc                  ;
                ret                     ;

FireBall        ld hl,KeyFP             ;
                call ReadKey            ;
                ret z                   ;

                call FindProjSpace      ;
                ret c                   ;

                ld a,(CurrentMagic)     ;
                sub 2                   ;
                ret c                   ;

                ld (CurrentMagic),a     ;
                ld hl,(pMan)            ;
                ld c,FBSR               ;
                ld a,(ManAngle)         ;
                call MonsterSearch      ;

                ld ix,(pNearMonster)    ;
                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;

                ld de,(pMan)            ;
                ld (iy+dp_Life),0       ;
                ret c                   ;

                set 7,(ix+dm_Combat)    ;
                call InitLine           ;

                ld hl,MoveFire          ;
                ld (iy+dp_pCode_L),l    ;
                ld (iy+dp_pCode_H),h    ;

                ld (iy+dp_MissileChar),#A4

                ld (iy+dp_Delay),FireSpeed
                ld (iy+dp_iDelay),FireSpeed

                ld (iy+dp_BackingChar),0;
                ld (iy+dp_Life),FireLife;

                ld hl,pMan              ;
                ld (iy+dp_pOwner_L),l   ;
                ld (iy+dp_pOwner_H),h   ;

                push ix                 ;
                pop hl                  ;

                ld (iy+dp_pTarget_L),l  ;
                ld (iy+dp_pTarget2_L),l ;
                ld (iy+dp_pTarget_H),h  ;
                ld (iy+dp_pTarget2_H),h ;

                ld (iy+dp_ManF),1       ;

                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                ld (iy+dp_TargetiPos_L),l
                ld (iy+dp_TargetiPos_H),h

                ld (iy+dp_UpdateRate),1 ;
                ret                     ;

MonSRange       defb 0                  ;

pNearMonster    defw 0                  ;

MFire1          ld (ix+dp_Life),0       ;
                ld e,(ix+dp_pTarget2_L) ;
                ld d,(ix+dp_pTarget2_H) ;
                push iy                 ;
                push de                 ;
                pop iy                  ;
                res 7,(iy+dm_Combat)    ;
                pop iy                  ;
                ret                     ;

MoveFire        inc (ix+dp_Life)        ;
                ld a,(ix+dp_MissileChar)
                inc a                   ;
                and #3                  ;
                or #A4                  ;
                ld (ix+dp_MissileChar),a
                push ix                 ;
                pop iy                  ;
                dec (iy+dp_UpdateRate)  ;
                jr nz MoveFireTM1       ;

                ld (iy+dp_UpdateRate),1 ;
                ld l,(iy+dp_pTarget_L)  ;
                ld h,(iy+dp_pTarget_H)  ;
                ld e,(hl)               ;
                inc hl                  ;
                ld d,(hl)               ;
                ld l,(iy+dp_TargetiPos_L)
                ld h,(iy+dp_TargetiPos_H)
                or a                    ;
                sbc hl,de               ;
                jp nz MoveFireTM        ;

MoveFireTM1     call NextPoint          ;
                jr c MFire1             ;

                ld a,(hl)               ;
                cp #20                  ;
                ret z                   ;

                and #FE                 ;
                cp #DC                  ;
                jr z MFire1             ;

                and #F0                 ;
                cp #90                  ;
                jr z MFire1             ;

                ld a,(hl)               ;
                and #F8                 ;
                cp #D0                  ;
                jr z HFireMon           ;

                cp #A8                  ;
                ret nz                  ;

                ld a,(iy+dp_ManF)       ;
                or a                    ;
                jp z HitManFire         ;

                ld a,FireLife           ;
                sub (iy+dp_Life)        ;
                cp 4                    ;
                ret c                   ;

                jp HitManFire           ;

        if def FixBug                   ;
HFireMon        ld l,(iy+dp_pOwner_L)   ;
                ld h,(iy+dp_pOwner_H)   ;
        else                            ;
HFireMon        ld l,(iy+10)            ; Bug! This was wrong
                ld h,(iy+11)            ; Bug! This was wrong
        endif                           ;

                ld e,(hl)               ;
                inc hl                  ;
                ld d,(hl)               ;
                ld l,(iy+dp_pMaze_L)    ;
                ld h,(iy+dp_pMaze_H)    ;
                ex de,hl                ;
                or a                    ;
                sbc hl,de               ;
                ex de,hl                ;
                jp nz HitMonFire        ;

                ld a,FireLife           ;
                sub (iy+dp_Life)        ;
                cp 3                    ;
                ret c                   ;

HitMonFire      ld a,FireDamageToMon    ;
                ld b,#E0                ;
                call MFire1             ;

                jp HitMonster           ;

MoveFireTM      ld a,(iy+dp_Life)       ;
                push af                 ;

                ld (iy+dp_TargetiPos_L),e
                ld (iy+dp_TargetiPos_H),d
                ld l,(iy+dp_pMaze_L)    ;
                ld h,(iy+dp_pMaze_H)    ;
                ex de,hl                ;

                call InitLine           ;

                ld hl,MoveFire          ;
                ld (iy+dp_pCode_L),l    ;
                ld (iy+dp_pCode_H),h    ;

                pop af                  ;
                ld (iy+dp_Life),a       ;

                jp MoveFireTM1          ;

Find a free projectile                  ;

FindProjSpace   ld iy,ProjList          ;
                ld b,nProj              ;
                ld de,lProj             ;

FPS1            ld a,(iy+dp_Life)       ;
                or a                    ;
                ret z                   ;

                add iy,de               ;

                djnz FPS1               ;

                scf                     ;
                ret                     ;

FuckUp          jp ITB                  ;

Should we try lightning?                ;

Lightning       ld a,(KeyL)             ;
                or a                    ;
                ret z                   ;

                call FindProjSpace      ;
                ret c                   ;

                ld a,(CurrentMagic)     ;
                sub 1                   ;
                ret c                   ;
                ld (CurrentMagic),a     ;

                ld hl,(pMan)            ;
                ld c,LtSR               ;
                ld a,(ManAngle)         ;

                call MonsterSearch      ;

                ld ix,(pNearMonster)    ;
                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                ld de,(pMan)            ;
                ld (iy+dp_Life),0       ;
                ret c                   ;

                call InitLine           ;

                ld hl,MoveLight         ;
                ld (iy+dp_pCode_L),l    ;
                ld (iy+dp_pCode_H),h    ;

                ld (iy+dp_MissileChar),#A2
                ld (iy+dp_Delay),LightSpeed
                ld (iy+dp_iDelay),LightSpeed
                ld (iy+dp_BackingChar),0
                ld (iy+dp_Life),LightLife
                ld hl,pMan              ;
                ld (iy+dp_pOwner_L),l   ;
                ld (iy+dp_pOwner_H),h   ;
                push ix                 ;
                pop hl                  ;
                ld (iy+dp_pTarget_L),l  ;
                ld (iy+dp_pTarget2_L),l ;
                ld (iy+dp_pTarget_H),h  ;
                ld (iy+dp_pTarget2_H),h ;
                ld (iy+dp_ManF),1       ;
                ld l,(ix+dm_pMaze_L)    ;
                ld h,(ix+dm_pMaze_H)    ;
                ld (iy+dp_TargetiPos_L),l
                ld (iy+dp_TargetiPos_H),h
                ld (iy+dp_UpdateRate),1 ;
                ret                     ;

MoveLight       inc (ix+dp_Life)        ;
                ld a,(ix+dp_MissileChar)
                inc a                   ;
                and #1                  ;
                or #A2                  ;
                ld (ix+dp_MissileChar),a
                push ix                 ;
                pop iy                  ;
                ld a,(iy+dp_ErrR)       ;
                ld (iy+dp_RSave),a      ;
                ld a,(iy+dp_pMaze_L)    ;
                ld (iy+dp_pMazeSave_L),a
                ld a,(iy+dp_pMaze_H)    ;
                ld (iy+dp_pMazeSave_H),a

MLRf0           call NextPoint          ;
                ret c                   ;

                ld a,(hl)               ;
                cp #20                  ;
                ret z                   ;

                and #FE                 ;
                cp #DC                  ;
                jp z MLightRefl         ;

                and #F0                 ;
                cp #90                  ;
                jp z MLightRefl         ;

                ld a,(hl)               ;
                and #F8                 ;
                cp #D0                  ;
                jr z HLightMon          ;

                cp #A8                  ;
                ret nz                  ;

                ld a,(iy+dp_ManF)       ;
                or a                    ;
                jp z HitManLight        ;

                ld a,LightLife          ;
                sub (iy+dp_Life)        ;
                cp 4                    ;
                ret c                   ;

                jp HitManLight          ;

        if def FixBug                   ;
HLightMon       ld l,(iy+dp_pOwner_L)   ;
                ld h,(iy+dp_pOwner_H)   ;
        else                            ;
HLightMon       ld l,(iy+10)            ; Bug! This was wrong
                ld h,(iy+11)            ; Bug! This was wrong
        endif                           ;

                ld e,(hl)               ;
                inc hl                  ;
                ld d,(hl)               ;

                ld l,(iy+dp_pMaze_L)    ;
                ld h,(iy+dp_pMaze_H)    ;

                ex de,hl                ;
                or a                    ;
                sbc hl,de               ;
                ex de,hl                ;

                jp nz HitMonLight       ;

                ld a,LightLife          ;
                sub (iy+dp_Life)        ;
                cp 3                    ;
                ret c                   ;

HitMonLight     ld a,LightDamageToMon   ;
                ld b,#E0                ;
                jp HitMonster           ;

MLightRefl      ld a,(iy+dp_RSave)      ;
                ld (iy+dp_ErrR),a       ;

                ld e,(iy+dp_pMazeSave_L)
                ld (iy+dp_pMaze_L),e    ;
                ld d,(iy+dp_pMazeSave_H)
                ld (iy+dp_pMaze_H),d    ;

                inc (iy+dp_Life)        ;

                ld l,(iy+dp_Step1_L)    ;
                ld h,(iy+dp_Step1_H)    ;
                add hl,de               ;

                call TestWall           ;
                jp nz MLRf1             ;

                ld l,(iy+dp_Step1_L)    ;
                ld h,(iy+dp_Step1_H)    ;
                push de                 ;
                ld de,0                 ;
                ex de,hl                ;
                or a                    ;
                sbc hl,de               ;
                ld (iy+dp_Step1_L),l    ;
                ld (iy+dp_Step1_H),h    ;
                pop de                  ;

MLRf1           ld a,(iy+dp_ErrS)       ;
                or a                    ;
                jp z MLRf0              ;

                xor a                   ;
                ex af,af'               ;
                ld h,(iy+dp_Off_H)      ;
                ld l,(iy+dp_Off_L)      ;

                push hl                 ;
                call Separate           ;
                ex (sp),hl              ;
                call RTest2             ;
                pop bc                  ;
                call RTest2             ;

                ld (iy+dp_Off_L),l      ;
                ld (iy+dp_Off_H),h      ;
                ex af,af'               ;
                or a                    ;
                jp nz,MLRf0             ;

                ld e,(iy+dp_Off_L)      ;
                ld d,(iy+dp_Off_H)      ;
                ld hl,0                 ;
                or a                    ;
                sbc hl,de               ;

                ld (iy+dp_Off_L),l      ;
                ld (iy+dp_Off_H),h      ;
                ld e,(iy+dp_Step1_L)    ;
                ld d,(iy+dp_Step1_H)    ;
                ld hl,0                 ;
                or a                    ;
                sbc hl,de               ;
                ld (iy+dp_Step1_L),l    ;
                ld (iy+dp_Step1_H),h    ;

                jp MLRf0                ;

TestWall        ld a,(hl)               ;

                and #FE                 ;
                cp #DC                  ;
                ret z                   ;

                and #F0                 ;
                cp #90                  ;
                ret                     ;

RTest2          push hl                 ;

                ld h,b                  ;
                ld l,c                  ;

                add hl,de               ;
                call TestWall           ;

                pop hl                  ;
                ret nz                  ;

                or a                    ;
                sbc hl,bc               ;

                or a                    ;
                sbc hl,bc               ;

                ld a,1                  ;

                ex af,af'               ;
                ret                     ;

Separate        bit 7,h                 ;

                ld bc,-128              ;
                jr nz,Sep1              ;

                ld bc,128               ;

Sep1            bit 6,l                 ;
                ld hl,-1                ;

                jr nz,Sep2              ;

                ld hl,1                 ;
Sep2            ret                     ;

ScanKeys        ld a,(KeyFlag)          ;
                inc a                   ;
                ld (KeyFlag),a          ;

                bit 0,a                 ;
                ret nz                  ;

                ld bc,65022             ;
                in a,(c)                ;
                bit 0,a                 ;
                ld hl,KeyA              ;
                call DWKey              ;

                ld bc,49150             ;
                in a,(c)                ;
                bit 1,a                 ;
                ld hl,KeyL              ;
                call DWKey              ;

                ld bc,65022             ;
                in a,(c)                ;
                bit 3,a                 ;
                ld hl,KeyF              ;
                call DWKey              ;

                ld bc,65022             ;
                in a,(c)                ;
                bit 2,a                 ;
                ld hl,KeyD              ;
                call DWKey              ;

                ld bc,49150             ;
                in a,(c)                ;
                bit 2,a                 ;
                ld hl,KeyK              ;
                call DWKey              ;

                ld bc,57342             ;
                in a,(c)                ;
                bit 1,a                 ;
                ld hl,KeyO              ;
                call DWKey              ;

                ld bc,65278             ;
                in a,(c)                ;
                bit 3,a                 ;
                ld hl,KeyC              ;
                call DWKey              ;

                ld bc,65022             ;
                in a,(c)                ;
                bit 1,a                 ;
                ld hl,KeyS              ;
                call DWKey              ;

                ld bc,32766             ;
                in a,(c)                ;
                bit 0,a                 ;
                ld hl,Keysp             ;
                call DWKey              ;

                ld bc,49150             ;
                in a,(c)                ;
                bit 4,a                 ;
                ld hl,KeyH              ;
                call DWKey              ;

                ld bc,63486             ;
                in a,(c)                ;
                bit 0,a                 ;
                ld hl,Key1              ;
                call DWKey              ;

                ld bc,63486             ;
                in a,(c)                ;
                bit 4,a                 ;
                ld hl,KeyAL             ;
                call DWKey              ;

                ld bc,61438             ;
                in a,(c)                ;
                bit 2,a                 ;
                ld hl,KeyAR             ;
                call DWKey              ;

                ld bc,61438             ;
                in a,(c)                ;
                bit 3,a                 ;
                ld hl,KeyAU             ;
                call DWKey              ;

                ld bc,61438             ;
                in a,(c)                ;
                bit 4,a                 ;
                ld hl,KeyAD             ;
                call DWKey              ;

; 2 key. Removed...                     ;

;                ld bc,63486            ;
;                in a,(c)               ;
;                bit 1,a                ;
;                ld hl,Key2             ;
;                call DWKey             ;

; W key. Removed...                     ;

;                ld bc,64510            ;
;                in a,(c)               ;
;                bit 1,a                ;
;                ld hl,KeyW             ;
;                call DWKey             ;

                ret                     ;

DWKey           jr nz KillDWKey         ;

                ld a,(hl)               ;
                or a                    ;
                ret nz                  ;

                ld (hl),1               ;
                inc hl                  ;
                ld a,1                  ;
                ld (hl),a               ;

                ret                     ;

KillDWKey       xor a                   ;
                ld (hl),a               ;
                ret                     ;

ReadKey         ld a,(hl)               ;
                or a                    ;
                ret z                   ;

                ld a,0                  ;
                ld (hl),a               ;
                ret                     ;

                ret                     ;

SideWall        ld ix,BigMaze+#70       ;
                ld (ix),#96             ;

                ld b,#70                ;
                ld de,#80               ;

SWallLP         add ix,de               ;
                ld (ix),#9C             ;

                ld a,(ix-1)             ;
                and #F0                 ;
                cp #90                  ;
                jr nz SWallLPE          ;

                set 1,(ix)              ;
SWallLPE        djnz SWallLP            ;

                ld (ix),#9A             ;

                ld a,(cFloor)           ;
                and #7                  ;
                inc a                   ;
                ld b,a                  ;

                ld hl,TopLeftSanc+14207 ;
                ld de,-896              ;

SancDoor        add hl,de               ;
                djnz SancDoor           ;

                ld (hl),#94             ;
                ld b,4                  ;
                ld de,-128              ;

SancD1          add hl,de               ;
                ld (hl),#90             ;

                djnz SancD1             ;

                add hl,de               ;
                ld (hl),#98             ;
                ret                     ;

; a := h mod 7                          ;

Bound7          push hl                 ;

                ld c,7                  ; / 7
                call Div                ;

                ld a,h                  ; * 7
                add a,a                 ;
                add a,a                 ;
                add a,a                 ;
                sub h                   ;
                pop hl                  ;
                ret                     ;

Div             xor a                   ;
                ld b,8                  ;

DivLoop         sla h                   ;
                rla                     ;
                cp c                    ;
                jr c DivLoopE           ;

                sub c                   ;
                inc h                   ;

DivLoopE        djnz DivLoop            ;

                ret                     ;

DisplayScore    ld hl,Key1P             ;
                call ReadKey            ;
                ret z                   ;

                call ClearSc            ;

                call InitScore          ;

DScore1         call ScanKeys           ;

                call TryHealing         ;

                call InitScore          ;

                ld hl,Key1P             ;
                call ReadKey            ;
                jr z DScore1            ;

                call ClearSc            ;

                call NewScreen          ;

                call PMD                ;

                ret                     ;

ArrowDir        ld a,(ArrDirC)          ;
                dec a                   ;
                ld (ArrDirC),a          ;

                or a                    ;
                ret nz                  ;

                ld a,8                  ;
                ld (ArrDirC),a          ;

                ld hl,KeyARP            ;
                call ReadKey            ;
                jr z ArrDir1            ;

                ld a,1                  ;
                ld (ArrDir),a           ;

                ret                     ;

ArrDir1         ld hl,KeyALP            ;
                call ReadKey            ;
                jr z ArrDir2            ;

                ld a,3                  ;
                ld (ArrDir),a           ;

                ret                     ;

ArrDir2         ld hl,KeyAUP            ;
                call ReadKey            ;
                jr z ArrDir3            ;

                ld a,0                  ;
                ld (ArrDir),a           ;

                ret                     ;

ArrDir3         ld hl,KeyADP            ;
                call ReadKey            ;
                ret z                   ;

                ld a,2                  ;
                ld (ArrDir),a           ;

                ret                     ;

Gen8            ld hl,RingTab+drt_Floor ;
                ld b,7                  ;
                ld (hl),0               ;

Gen8R           inc hl                  ;
                inc hl                  ;
                inc hl                  ;

                ld a,7                  ;
                call RandRange          ;
                inc a                   ;
                ld (hl),a               ;

                djnz Gen8R              ;

                ld a,0                  ;
                ld (nDTs),a             ;
                ld (cFloor),a           ;
                ld (NRings),a           ;

Gen8A           call gpMazeList         ;

                ld de,(Seed)            ;
                ld (hl),e               ;
                inc hl                  ;
                ld (hl),d               ;
                inc hl                  ;

                ld de,(Seed+2)          ;
                ld (hl),e               ;
                inc hl                  ;
                ld (hl),d               ;
                inc hl                  ;

                call MAIN               ;

                call PAGE               ;

                call InitMonsters       ;

                call InitTreasure       ;

                call InitMagic          ;

                call SaveFloor          ;

                ld a,(cFloor)           ;
                and #7                  ;

                ld iy,RingTab           ;
                ld b,8                  ;

Gen8RA          cp (iy+drt_Floor)       ;
                call z DefRing          ;

                inc iy                  ;
                inc iy                  ;
                inc iy                  ;

                djnz Gen8RA             ;

                inc a                   ;
                ld (cFloor),a           ;
                cp 8                    ;
                jr nz Gen8A             ;

                ret                     ;

DefRing         push af                 ;

DefRing1        call FindPosition       ;

                ld (iy+drt_pMaze_L),l   ;
                ld (iy+drt_pMaze_H),h   ;
                ld (hl),#88             ;

                call XYC                ;

                ld a,l                  ;
                cp 30                   ;
                jr nc DefRing1          ;

                pop af                  ;
                ret                     ;

gpMazeList      ld a,(cFloor)           ; 512 bytes per floor
                and #7                  ;
                add a,a                 ;
                ld d,a                  ;
                ld e,0                  ;

                ld hl,MazeList          ;
                add hl,de               ;

                ret                     ;

SaveFloor       call gpMazeList         ;

                inc hl                  ;
                inc hl                  ;
                inc hl                  ;
                inc hl                  ;

                ld ix,MonsterList       ;
                ld de,lMonst            ;
                ld b,nMonst             ;

SFloor1         ld a,(ix+dm_pMaze_L)    ;
                ld (hl),a               ;
                inc hl                  ;
                ld a,(ix+dm_pMaze_H)    ;
                ld (hl),a               ;
                inc hl                  ;
                ld a,(ix+dm_Char)       ;
                ld (hl),a               ;
                inc hl                  ;
                ld a,(ix+dm_Flags)      ;
                and #80                 ;
                or (ix+dm_MoveType)     ;
                ld (hl),a               ;
                inc hl                  ;

                add ix,de               ;

                djnz SFloor1            ;

                ld de,BigMaze           ;
                ld c,#70                ;
SFloor2         ld b,#70                ;
SFloor3         ld a,(de)               ;
                and #F0                 ;
                cp #B0                  ;
                jr c SFloor3A           ;

                cp #D0                  ;
                jr nc SFloor3A          ;

                ld a,(de)               ;
                ld (hl),e               ;
                inc hl                  ;
                ld (hl),d               ;
                inc hl                  ;
                ld (hl),a               ;
                inc hl                  ;

SFloor3A        inc de                  ;
                djnz SFloor3            ;

                push hl                 ;
                ld hl,#10               ;
                add hl,de               ;
                ex de,hl                ;
                pop hl                  ;

                dec c                   ;
                jr nz SFloor2           ;

                ld (hl),0               ;
                inc hl                  ;
                ld (hl),0               ;
                inc hl                  ;
                ld (hl),0               ;
                ret                     ;

Recreate        call gpMazeList         ;

                ld de,Seed              ;
                ld bc,4                 ;
                ldir                    ;

                push hl                 ;

                call MAIN               ;

                call PAGE               ;

                call InitMonsters       ;

                pop iy                  ;

                ld ix,MonsterList       ;
                ld de,lMonst            ;
                ld b,nMonst             ;

Rec1            ld l,(iy+dml_pMaze_L)   ;
                ld h,(iy+dml_pMaze_H)   ;
                ld a,(hl)               ;
                cp #20                  ;
                ld (ix+dm_pMaze_L),l    ;
                ld (ix+dm_pMaze_H),h    ;

                call nz OpenIfNess      ;

                ld a,(iy+dml_Char)      ;
                ld (ix+dm_Char),a       ;
                ld a,(iy+dml_MoveType)  ;
                and #3                  ;
                ld (ix+dm_MoveType),a   ;
                ld a,(iy+dml_MoveType)  ;

                inc iy                  ;
                inc iy                  ;
                inc iy                  ;
                inc iy                  ;

                and #80                 ;
                or (ix+dm_Flags)        ;
                ld (ix+dm_Flags),a      ;
                add ix,de               ;

                djnz Rec1               ;

Rec2            ld l,(iy)               ;
                inc iy                  ;
                ld h,(iy)               ;
                inc iy                  ;
                ld a,(iy)               ;
                inc iy                  ;

                or a                    ;
                jr z Rec3               ;

                ld a,(hl)               ;
                cp #20                  ;
                call nz OpenIfNess      ;

                ld a,(iy-1)             ;
                ld (hl),a               ;

                jr Rec2                 ;

Rec3            call IPL                ;

                ld ix,RingTab           ;
                ld b,8                  ;
                ld c,#88                ;
                ld a,(cFloor)           ;

Rec4            cp (ix+drt_Floor)       ;
                jr nz Rec5              ;

                ld l,(ix+drt_pMaze_L)   ;
                ld h,(ix+drt_pMaze_H)   ;
                ld (hl),c               ;

Rec5            inc c                   ;
                inc ix                  ;
                inc ix                  ;
                inc ix                  ;

                djnz Rec4               ;

                xor a                   ;
                ld (Virgin),a           ;

                ret                     ;

OpenIfNess      push hl                 ;
                push af                 ;
                push de                 ;
                push bc                 ;

                cp #DC                  ;
                jr z OINHor             ;

                cp #DD                  ;
                jr z OINVer             ;

OINEx           pop bc                  ;
                pop de                  ;
                pop af                  ;
                pop hl                  ;
                ret                     ;

OINHor          ld de,1                 ;
                call MMDoorO2           ;
                jr OINEx                ;

OINVer          ld de,128               ;
                call MMDoorO2           ;
                jr OINEx                ;

InitSanctuary   ld hl,BigMaze           ;
                ld de,BigMaze+1         ;
                ld bc,#3FFF             ;
                ld (hl),#20             ;
                ldir                    ;

                ld hl,TopLeftSanc       ;
                ld (hl),#95             ;
                ld b,13                 ;
InitSanc1       inc hl                  ;
                ld (hl),#93             ;
                djnz InitSanc1          ;

                inc hl                  ;
                ld (hl),#96             ;
                ld de,128               ;
                ld b,111                ;
InitSanc2       add hl,de               ;
                ld (hl),#9C             ;
                djnz InitSanc2          ;

                add hl,de               ;
                ld (hl),#9A             ;
                ld b,13                 ;
InitSanc3       dec hl                  ;
                ld (hl),#93             ;
                djnz InitSanc3          ;

                dec hl                  ;
                ld (hl),#99             ;
                ld de,-128              ;
                ld b,13                 ;
InitSanc4       add hl,de               ;
                ld (hl),#9C             ;
                djnz InitSanc4          ;

                ld b,7                  ;

InitSanc5       add hl,de               ;
                ld (hl),#9C             ;
                add hl,de               ;
                ld (hl),#94             ;
                add hl,de               ;
                ld (hl),#90             ;
                add hl,de               ;
                ld (hl),#90             ;
                add hl,de               ;
                ld (hl),#90             ;
                add hl,de               ;
                ld (hl),#90             ;
                add hl,de               ;
                ld (hl),#98             ;
                djnz InitSanc5          ;

                push hl                 ;
                ld b,49                 ;
InitSanc6       add hl,de               ;
                ld (hl),#9C             ;
                djnz InitSanc6          ;
                pop hl                  ;

                ld (hl),#99             ;
                push hl                 ;

                ld de,-3584             ;
                add hl,de               ;

                ld (hl),#9D             ;
                ld b,13                 ;
InitSanc7       inc hl                  ;
                ld (hl),#93             ;
                djnz InitSanc7          ;

                inc hl                  ;
                ld (hl),#9E             ;

                pop hl                  ;
                push hl                 ;

                ld b,6                  ;
InitSanc7a      inc hl                  ;
                ld (hl),#93             ;
                djnz InitSanc7a         ;

                ld (hl),#96             ;
                ld de,128               ;
                ld b,55                 ;

InitSanc8       add hl,de               ;
                ld (hl),#9C             ;
                djnz InitSanc8          ;

                add hl,de               ;
                ld (hl),#98             ;

                pop hl                  ;

                ld de,129               ;
                add hl,de               ;

                ld c,#87                ;
InitSancD       ld a,#FC                ;
                call Rung               ;

                ld b,3                  ;
                ld a,c                  ;

InitSanc9       call Rung               ;
                djnz InitSanc9          ;

                ld b,3                  ;
                ld a,#FD                ;

InitSancB       call Rung               ;
                djnz InitSancB          ;

                dec c                   ;
                ld a,c                  ;
                cp #7F                  ;
                jr nz InitSancD         ;

                ld b,5                  ;
                ld a,#FC                ;
InitSancE       call Rung               ;
                djnz InitSancE          ;

                ld b,16                 ;
                ld de,SMess             ;
                ld hl,TopLeftSanc+258   ;

SMessL          ld c,11                 ;
                push hl                 ;

SMessl          ld a,(de)               ;
                ld (hl),a               ;
                inc de                  ;
                inc hl                  ;
                dec c                   ;
                jr nz SMessl            ;

                pop hl                  ;
                push bc                 ;

                ld bc,128               ;
                add hl,bc               ;

                pop bc                  ;
                djnz SMessL             ;

                ret                     ;

SMess           db "Halls Of   "        ;
                db "The Things "        ;
                db "           "        ;
                db "1983..2006 "        ;
                db "           "        ;
                db "Things     "        ;
                db "trained by "        ;
                db "           "        ;
                db "Martin     "        ;
                db "Horsley    "        ;
                db "           "        ;
                db "Neil       "        ;
                db "Mottershead"        ;
                db "           "        ;
                db "Simon      "        ;
                db "Brattel    "        ;

Rung            push bc                 ;

                ld b,5                  ;
Rung1           ld (hl),a               ;
                inc hl                  ;
                djnz Rung1              ;

                ld bc,#80-5             ;
                add hl,bc               ;

                pop bc                  ;
                ret                     ;

; See if the floor has changed          ;

NFloor          ld a,(NFloorFl)         ; New floor -> b
                dec a                   ;
                ld b,a                  ;

                ld a,(cFloor)           ; Ignore if cfloor=8
                cp 8                    ;
                ret z                   ;

                and #7                  ; Has the floor changed?
                cp b                    ;
                ret z                   ; No.

                ; Different floor.      ;

                push bc                 ; Save the current floor
                call SaveFloor          ;
                pop bc                  ;

                ld a,b                  ; Change to the new floor
                ld (cFloor),a           ;

                call Recreate           ; Recreate the new floor

                call PlaceMon           ; Place the monsters

                call NewScreen          ; Update the screen

                jp PM                   ; Draw the man

; See if a monster wants to open a door.

MonODoor        push hl                 ;
                push de                 ;
                push bc                 ;

                ld a,(hl)               ;
                and #FE                 ;
                cp #DC                  ;
                jr nz MonODoorEx        ;

                call FindProjSpace      ;

                pop bc                  ;
                pop de                  ;
                pop hl                  ;

                push hl                 ;
                push de                 ;
                push bc                 ;

                ld c,50                 ;

                push hl                 ;
                or a                    ;
                sbc hl,de               ;

                ld de,(pMan)            ;
                call RangeDoor          ;
                pop hl                  ;

                ld (iy+dp_Life),0       ;
                jr c,MonODRnd           ;

                ld a,(DoorFlag)         ;
                or a                    ;
                jr z,MonODRnd           ;

                ld a,(hl)               ;
                call OpenIfNess         ;

                call MoveT2Mark         ;

                pop bc                  ;
                pop de                  ;
                pop hl                  ;

                or a                    ;
                sbc hl,de               ;

                ret                     ;

MonODRnd        ld a,r                  ;
                and 3                   ;
                jr nz MonODoorEx        ;

                ld a,(hl)               ;
                call OpenIfNess         ;

                call MoveT2Mark         ;

MonODoorEx      pop bc                  ;
                pop de                  ;
                pop hl                  ;
                ret                     ;

MAIN            push de                 ;
                push iy                 ;

                ld a,(cFloor)           ;
                and #7                  ;
                ld iy,ConTab            ;
                ld e,a                  ;
                ld d,0                  ;
                add iy,de               ;

                call Main               ;

MAINEx          pop iy                  ;
                pop de                  ;

                ret                     ;

MMKRing         ld a,c                  ;
                and 7                   ;
                ld e,a                  ;

                ld d,0                  ;
                ld ix,RingTab           ;

                add ix,de               ;
                add ix,de               ;
                add ix,de               ;

                ld (ix+drt_Floor),#FF   ;

                ld a,#20                ;
                ld (hl),a               ;

                call SCV                ;

                call nc OutIt           ;

                ld a,c                  ;
                cp #88                  ;
                jr nz MMKRingB          ;

                ld a,8                  ;
                ld (cFloor),a           ;

MMKRingB        ld a,(NRings)           ;
                inc a                   ;
                ld (NRings),a           ;

                cp 7                    ;
                scf                     ;
                ccf                     ;
                ret nz                  ;

; Open the bottom floor's door...       ;

GoldKey         ld b,6                  ;
                ld de,-128              ;
                ld ix,TopLeftSanc+13312 ;
                ld iy,TopLeftSanc+12416 ;

MMKRingA        ld a,(iy)               ;
                ld (ix),a               ;

                add ix,de               ;
                add iy,de               ;

                djnz MMKRingA           ;

                or a                    ;
                ret                     ;

PAGE            ld a,(cFloor)           ;
                and #7                  ;
                jp nz Page              ;

                call Init               ;

                ld hl,BigMaze           ;
                ld b,#6F                ;
                ld (hl),#95             ;

PAGE1           inc hl                  ;
                ld (hl),#93             ;
                djnz PAGE1              ;

                ld hl,BigMaze           ;
                ld b,#6F                ;
                ld de,128               ;
PAGE2           add hl,de               ;
                ld (hl),#9C             ;
                djnz PAGE2              ;

                jp PageC22              ;

OpenPlan        ld a,(cFloor)           ;
                and #7                  ;
                jr nz OpenPlanFEx       ;

                ld a,(Virgin)           ;
                or a                    ;
                ret z                   ;

                ld a,(cFloor)           ;
                cp 8                    ;
                ret nz                  ;

                jp DunIt                ;

OpenPlanFEx     xor a                   ;
                ret                     ;

RangeLook       call RangeDoor          ;

                push af                 ;

                ld a,(DoorFlag)         ;
                or a                    ;
                jr z,RDFin              ;

                pop af                  ;

                scf                     ;
                ret                     ;

RDFin           pop af                  ;
                ret                     ;

        if false                        ;
DoorHackOpen    ld hl,Key2P             ;
                call ReadKey            ;
                ret z                   ;

                ld a,#FF                ;
                ld (JFLAG),a            ;

                jp GoldKey              ;
        endif                           ;

CTres           ld hl,BigMaze           ;
                ld bc,#4000             ;
                ld de,0                 ;

CTresL          ld a,(hl)               ;
                and #F0                 ;
                cp #B0                  ;
                jr nz,CTresN            ;

                ld a,(hl)               ;
                and #F                  ;
                add a,e                 ;
                ld e,a                  ;
                ld a,0                  ;
                adc a,d                 ;
                ld d,a                  ;

CTresN          cpi                     ;
                jp v CTresL             ;

                ret                     ;

DoScor          call CTres              ;

DoS1            ld hl,(nDTs)            ;
                ld h,0                  ;
                add hl,hl               ;
                add hl,de               ;

                ld a,(NRings)           ;
                ld d,a                  ;
                ld e,0                  ;
                srl d                   ;
                rr e                    ;
                add hl,de               ;
                cp 8                    ;
                ret nz                  ;

                ld de,128               ;
                add hl,de               ;

                ret                     ;

CQuit           ld bc,64510             ;
                in a,(c)                ;
                or #E0                  ;
                cp #EE                  ;
                ret nz                  ;

                ld bc,57342             ;
                in a,(c)                ;
                or #E0                  ;
                cp #F3                  ;
                ret nz                  ;

                jp Quit                 ;

ManKilled       call ClearSc            ;

                ld de,0                 ;
                call DoS1               ;

                ld b,0                  ;
                jr FOut                 ;

DunIt           call ClearSc            ;

                call DoScor             ;

                ld b,1                  ;
FOut            ld sp,(Stack)           ;
                push hl                 ;

                xor a                   ;
                ld hl,(NRings)          ;
                ld h,a                  ;
                push hl                 ;

                ld hl,(nDTs)            ;
                ld h,a                  ;
                push hl                 ;

                ld iy,(RetAddr)         ;
                ld l,b                  ;
                push hl                 ;

                jp (iy)                 ;

Quit            call ClearSc            ;

                ld de,0                 ;
                call DoS1               ;

                ld b,2                  ;
                jr FOut                 ;

ITB             di                      ;
                pop hl                  ;

                ld (Stack),sp           ;
                ld (RetAddr),hl         ;

STARTGAME       call InitSanctuary      ;

                call InitGame           ;

STARTLOOP       call Gen8               ;

                call ClearSc            ;

                jr Telep0               ;

NewFloor        call PM                 ;

                call IPL                ;

                call NewScreen          ;

                ld a,0                  ; Clear the sword
                ld (SwdPhase),a         ;

GameLoop        call MoveMan            ;

                call MoveMonsters       ;

                call MoveProj           ;

                call ScanKeys           ;

                call JustifyScreen      ;

                call TryHealing         ;

                call DisplayScore       ;

                call ArrowDir           ;

                call Rnd7               ;
                ld r,a                  ;

                jr GameLoop             ;

Telep0          ld a,0                  ;
                ld (cFloor),a           ;

                call Recreate           ;

                call PlaceMon           ;

                ld hl,BigMaze+14077     ;
                ld (pMan),hl            ;
                call XYC                ;
                ld (pFrameX),hl         ;

                ld hl,0                 ;
                ld (ManOPosXY),hl       ;

                call JustifyT           ;

                jr NewFloor             ;

InitGame        ld a,0                  ;
                out (#FE),a             ;

                ld a,#FF                ;
                ld (pFrameX),a          ;
                ld (pFrameY),a          ;

                ld a,0                  ;
                ld (Wounds),a           ;
                ld (TreasureCount),a    ;

                ld a,120                ;
                ld (CurrentMagic),a     ;

                ld a,255                ;
                ld (ArrowCount),a       ;

                ld a,0                  ;
                ld (UnderMan),a         ;
                ld (JFLAG),a            ;

                ret                     ;

ClearSc         ld hl,#4000             ;
                ld de,#4001             ;
                ld bc,#1B00             ;
                ld (hl),#0              ;
                ldir                    ;

                ret                     ;

TryHealing      ld hl,KeyHP             ;
                call ReadKey            ;
                ret z                   ;

                ld a,(CurrentMagic)     ;
                sub 30                  ;
                ret c                   ;

                ld (CurrentMagic),a     ;
                ld a,r                  ;
                and #F                  ;
                add a,16                ;
                ld b,a                  ;
                ld a,(Wounds)           ;
                sub b                   ;
                bit 7,a                 ;
                jr z TryHeal1           ;

                xor a                   ;
TryHeal1        ld (Wounds),a           ;

                ret                     ;

InitScore       ld hl,ScorePos+#E       ;
                ld de,SMess1            ;
                call SPrint             ;

                ld hl,ScorePos+#100     ;
                ld de,SMess3            ;
                call SPrint             ;

                ld hl,ScorePos+#200     ;
                ld de,SMess4            ;
                call SPrint             ;

                ld hl,ScorePos+#300     ;
                ld de,SMess9            ;
                call SPrint             ;

                ld hl,ScorePos+#400     ;
                ld de,SMess5            ;
                call SPrint             ;

                ld hl,0                 ;
                ld de,SMess6            ;
                call SPrint             ;

                ld hl,#100              ;
                ld de,SMess7            ;
                call SPrint             ;

                ld hl,#400              ;
                ld de,SMess8            ;
                call SPrint             ;

                ld hl,#600              ;
                ld de,SMessN1           ;
                call SPrint             ;

                ld hl,#700              ;
                ld de,SMessN2           ;
                call SPrint             ;

                ld hl,#800              ;
                ld de,SMessN3           ;
                call SPrint             ;

                call PrintMagic         ;

                call PrintWound         ;

                call PrintDTs           ;

                call PrintArrows        ;

                ld de,SMessA            ;
                ld hl,#F01              ;
                call SPrint             ;

                ld ix,RingTab+lRingTable*8
                ld hl,#F0F              ;
                ld bc,#088F             ;

PRLp            ld a,(ix+drt_Floor-3)   ;
                cp #FF                  ;
                jr nz PRLp1             ;

                ld a,c                  ;
                call OutIt              ;

                inc l                   ;

PRLp1           dec c                   ;
                dec ix                  ;
                dec ix                  ;
                dec ix                  ;

                djnz PRLp               ;

                ret                     ;

SPrint          ld a,(de)               ;
                or a                    ;
                ret z                   ;

                call OutIt              ;

                inc de                  ;
                inc hl                  ;

                jr SPrint               ;

SMess1          defb "100%          0%",0
SMess3          defb "Magic",0          ;
SMess4          defb "Wounds",0         ;
SMess5          defb "Arrows",0         ;
SMess9          defb "Dead Things",0    ;
SMessA          defb "Rings found",0    ;
SMess6          defb " -- Halls of the Things --",0
SMess7          defb "___________________________",0
SMess8          defb "(c) Design-Design Software",0
SMessN1         defb "    Simon Brattel",0
SMessN2         defb "    Neil Mottershead",0
SMessN3         defb " &  Martin Horsley",0

PrintMagic      ld hl,ScorePos+#10D     ;
                ld a,(CurrentMagic)     ;
                jr PrintBar             ;

PrintWound      ld hl,ScorePos+#20D     ;
                ld a,(Wounds)           ;
                add a,a                 ;
                jr PrintBar             ;

PrintArrows     ld hl,ScorePos+#40D     ;
                ld a,(ArrowCount)       ;
                jr PrintBar             ;

PrintDTs        ld hl,ScorePos+#30D     ;
                ld a,(nDTs)             ;

PrintBar        srl a                   ;
                call PBarF1             ;

                cp #FF                  ;
                jr z PBarF              ;

                ld de,17                ;
                add hl,de               ;

                ld d,15                 ;
                call PBarF2             ;

                dec hl                  ;
                ld c,a                  ;
                srl a                   ;
                srl a                   ;
                srl a                   ;
                or a                    ;
                jr z PBarE              ;

                ld b,a                  ;
PBarL           call PBarF0             ;

                dec hl                  ;
                dec d                   ;

                djnz PBarL              ;

PBarE           ld a,c                  ;
                and #7                  ;
                or #E8                  ;
                call OutIt              ;

                ld a,d                  ;
                or a                    ;
                jr z PBarEx             ;

                ld b,d                  ;

PBarL2          dec hl                  ;
                ld a,#E8                ;
                call OutIt              ;

                djnz PBarL2             ;

PBarEx          ret                     ;

PBarF           ld b,16                 ;

PBarFl          call PBarF0             ;

                dec hl                  ;
                djnz PBarFl             ;

                ret                     ;

PBarF0          push af                 ;
                ld a,#F0                ;
                call OutIt              ;
                pop af                  ;
                ret                     ;

PBarF1          push af                 ;
                ld a,#F1                ;
                call OutIt              ;
                pop af                  ;
                ret                     ;

PBarF2          push af                 ;
                ld a,#F2                ;
                call OutIt              ;
                pop af                  ;
                ret                     ;

Data

SwdUpTab        defb #00,#00,#E5        ;
                defb #FF,#FF,#E6        ;
                defb #00,#00,#E5        ;
                defb #01,#00,#E4        ;
                defb #00,#00,#E5        ;
                defb #FF,#FF,#E6        ;
                defb #00,#00,#E5        ;
                defb #01,#00,#E4        ;
                defb #00,#00,#E5        ;
                defb 0,0,0,0,0          ;

SwdRtTab        defb #00,#00,#E4        ;
                defb #80,#00,#E7        ;
                defb #80,#00,#E6        ;
                defb #80,#00,#E7        ;
                defb #00,#00,#E4        ;
                defb #80,#00,#E7        ;
                defb #80,#00,#E6        ;
                defb #80,#00,#E7        ;
                defb #00,#00,#E4        ;
                defb 0,0,0,0,0          ;

SwdDnTab        defb #00,#00,#E5        ;
                defb #FF,#FF,#E4        ;
                defb #00,#00,#E5        ;
                defb #01,#00,#E6        ;
                defb #00,#00,#E5        ;
                defb #FF,#FF,#E4        ;
                defb #00,#00,#E5        ;
                defb #01,#00,#E6        ;
                defb #00,#00,#E5        ;
                defb 0,0,0,0,0          ;

SwdLfTab        defb #00,#00,#E6        ;
                defb #80,#00,#E7        ;
                defb #80,#00,#E4        ;
                defb #80,#00,#E7        ;
                defb #00,#00,#E6        ;
                defb #80,#00,#E7        ;
                defb #80,#00,#E4        ;
                defb #80,#00,#E7        ;
                defb #00,#00,#E6        ;

WallDefs        defb #9C,#9C,#9C,#9C,#9C,#9C,0,0
                defb #98,#DD,#DD,#DD,#DD,#94,0,0
                defb #98,#20,#20,#20,#20,#94,0,0
                defb #20,#20,#20,#20,#20,#20,0,0
                defb #93,#93,#93,#93,#93,#93,0,0
                defb #92,#DC,#DC,#DC,#DC,#91,0,0
                defb #92,#20,#20,#20,#20,#91,0,0
                defb #20,#20,#20,#20,#20,#20,0,0

First we have the base value

MonsterTypes    defb 0,0                ; pMaze
                defb #D0                ; Char
                defb 0                  ; MoveType
                defb 100                ; Strength
                defb 0                  ; Flags
                defb 16                 ; Magic
                defb 32                 ; MaxMagic
                defb 0                  ; Treasure
                defb 0                  ; MaxTreasure
                defb 60                 ; Delay
                defb 60                 ; iDelay
                defb 4                  ; nArrows
                defb 30                 ; Wounds
                defb 0                  ; Combat
                defb 0                  ; Direction
                defb 0,0,0,0            ; Cache

Then we have the range of variation allowed for each byte

                defb 0,0                ; pMaze
                defb 8                  ; Char
                defb 3                  ; MoveType
                defb 20                 ; Strength
                defb 0                  ; Flags
                defb 8                  ; Magic
                defb 16                 ; MaxMagic
                defb 0                  ; Treasure
                defb 0                  ; MaxTreasure
                defb 0                  ; Delay
                defb 90                 ; iDelay
                defb 3                  ; nArrows
                defb 20                 ; Wounds
                defb 0                  ; Combat
                defb 0                  ; Direction
                defb 0,0,0,0            ; Cache

        ; Make sure it's sensible

        if ((*-MonsterTypes)/2) <> lMonsterFixed
          def 31
        endif

Screen address conversion

SpecTab         defw #4000,#4020,#4040,#4060
                defw #4080,#40A0,#40C0,#40E0
                defw #4800,#4820,#4840,#4860
                defw #4880,#48A0,#48C0,#48E0
                defw #5000,#5020,#5040,#5060
                defw #5080,#50A0,#50C0,#50E0
                defw #0000,#0000,#0000,#0000

Maze type probabilities

ConTab          defb   0,255,200,150,127,100, 60, 20
                defb   0,150,100, 40, 23, 13,  7,  4
                defb   0,200,100, 50, 30, 20, 10,  5

Key flags                               ;

KeyA            defb 0                  ;
KeyAP           defb 0                  ;
KeyL            defb 0                  ;
KeyLP           defb 0                  ;
KeyF            defb 0                  ;
KeyFP           defb 0                  ;
KeyD            defb 0                  ;
KeyDP           defb 0                  ;
KeyK            defb 0                  ;
KeyKP           defb 0                  ;
KeyO            defb 0                  ;
KeyOP           defb 0                  ;
KeyC            defb 0                  ;
KeyCP           defb 0                  ;
KeyS            defb 0                  ;
KeySP           defb 0                  ;
Keysp           defb 0                  ;
KeyspP          defb 0                  ;
KeyH            defb 0                  ;
KeyHP           defb 0                  ;
Key1            defb 0                  ;
Key1P           defb 0                  ;
KeyT            defb 0                  ;
KeyTP           defb 0                  ;
KeyAL           defb 0                  ;
KeyALP          defb 0                  ;
KeyAR           defb 0                  ;
KeyARP          defb 0                  ;
KeyAU           defb 0                  ;
KeyAUP          defb 0                  ;
KeyAD           defb 0                  ;
KeyADP          defb 0                  ;
KeyFlag         defb 0                  ;

MaxMagic        equ 255                 ;
CurrentMagic    defb 5                  ;
Wounds          defb 0                  ;
MaxWounds       equ 127                 ;
TempStore       defb 0                  ;
Score           defw 0                  ;
ArrowCount      defb 255                ;
TreasureCount   defb 0                  ;
nDTs            defb 0                  ;
SwdPhase        defb 0                  ;
SwdPos          defw 0                  ;
SwagBag         defs MaxTreasure        ;
ArrDir          defb 1                  ;
ArrDirC         defb 8                  ;
cFloor          defb 0                  ;
DoorFlag        defb 0                  ;
NFloorFl        defb 0                  ;
UnderMan        defb 0                  ;
JFLAG           defb 0                  ;
Stack           defw 0                  ;
RetAddr         defw 0                  ;
NRings          defb 0                  ;
Virgin          defb 0                  ;

Define the positions of the rings

RingTab         ds lRingTable*8,0       ;

The maze

BigMaze         defs 16384              ;
TopLeftSanc     equ BigMaze+113         ;

The definition of each floor

MazeList        defs 8*512              ;

The monsters

MonsterList     defs nMonst * lMonst    ;

The projectiles

ProjList        defs nProj * lProj      ;

The small maze, one byte per room

                align 256               ;
Maze            defs #100               ;

The end

Ye_End          equ *